1 /* 2 * Universal Interface for Intel High Definition Audio Codec 3 * 4 * HD audio interface patch for SigmaTel STAC92xx 5 * 6 * Copyright (c) 2005 Embedded Alley Solutions, Inc. 7 * Matt Porter <mporter@embeddedalley.com> 8 * 9 * Based on patch_cmedia.c and patch_realtek.c 10 * Copyright (c) 2004 Takashi Iwai <tiwai@suse.de> 11 * 12 * This driver is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This driver is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 25 */ 26 27 #include <linux/init.h> 28 #include <linux/delay.h> 29 #include <linux/slab.h> 30 #include <linux/pci.h> 31 #include <linux/dmi.h> 32 #include <linux/module.h> 33 #include <sound/core.h> 34 #include <sound/asoundef.h> 35 #include <sound/jack.h> 36 #include <sound/tlv.h> 37 #include "hda_codec.h" 38 #include "hda_local.h" 39 #include "hda_auto_parser.h" 40 #include "hda_beep.h" 41 #include "hda_jack.h" 42 43 enum { 44 STAC_VREF_EVENT = 1, 45 STAC_INSERT_EVENT, 46 STAC_PWR_EVENT, 47 STAC_HP_EVENT, 48 STAC_LO_EVENT, 49 STAC_MIC_EVENT, 50 }; 51 52 enum { 53 STAC_AUTO, 54 STAC_REF, 55 STAC_9200_OQO, 56 STAC_9200_DELL_D21, 57 STAC_9200_DELL_D22, 58 STAC_9200_DELL_D23, 59 STAC_9200_DELL_M21, 60 STAC_9200_DELL_M22, 61 STAC_9200_DELL_M23, 62 STAC_9200_DELL_M24, 63 STAC_9200_DELL_M25, 64 STAC_9200_DELL_M26, 65 STAC_9200_DELL_M27, 66 STAC_9200_M4, 67 STAC_9200_M4_2, 68 STAC_9200_PANASONIC, 69 STAC_9200_MODELS 70 }; 71 72 enum { 73 STAC_9205_AUTO, 74 STAC_9205_REF, 75 STAC_9205_DELL_M42, 76 STAC_9205_DELL_M43, 77 STAC_9205_DELL_M44, 78 STAC_9205_EAPD, 79 STAC_9205_MODELS 80 }; 81 82 enum { 83 STAC_92HD73XX_AUTO, 84 STAC_92HD73XX_NO_JD, /* no jack-detection */ 85 STAC_92HD73XX_REF, 86 STAC_92HD73XX_INTEL, 87 STAC_DELL_M6_AMIC, 88 STAC_DELL_M6_DMIC, 89 STAC_DELL_M6_BOTH, 90 STAC_DELL_EQ, 91 STAC_ALIENWARE_M17X, 92 STAC_92HD73XX_MODELS 93 }; 94 95 enum { 96 STAC_92HD83XXX_AUTO, 97 STAC_92HD83XXX_REF, 98 STAC_92HD83XXX_PWR_REF, 99 STAC_DELL_S14, 100 STAC_DELL_VOSTRO_3500, 101 STAC_92HD83XXX_HP_cNB11_INTQUAD, 102 STAC_HP_DV7_4000, 103 STAC_HP_ZEPHYR, 104 STAC_92HD83XXX_HP_LED, 105 STAC_92HD83XXX_HP_INV_LED, 106 STAC_92HD83XXX_MODELS 107 }; 108 109 enum { 110 STAC_92HD71BXX_AUTO, 111 STAC_92HD71BXX_REF, 112 STAC_DELL_M4_1, 113 STAC_DELL_M4_2, 114 STAC_DELL_M4_3, 115 STAC_HP_M4, 116 STAC_HP_DV4, 117 STAC_HP_DV5, 118 STAC_HP_HDX, 119 STAC_HP_DV4_1222NR, 120 STAC_92HD71BXX_MODELS 121 }; 122 123 enum { 124 STAC_925x_AUTO, 125 STAC_925x_REF, 126 STAC_M1, 127 STAC_M1_2, 128 STAC_M2, 129 STAC_M2_2, 130 STAC_M3, 131 STAC_M5, 132 STAC_M6, 133 STAC_925x_MODELS 134 }; 135 136 enum { 137 STAC_922X_AUTO, 138 STAC_D945_REF, 139 STAC_D945GTP3, 140 STAC_D945GTP5, 141 STAC_INTEL_MAC_V1, 142 STAC_INTEL_MAC_V2, 143 STAC_INTEL_MAC_V3, 144 STAC_INTEL_MAC_V4, 145 STAC_INTEL_MAC_V5, 146 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter 147 * is given, one of the above models will be 148 * chosen according to the subsystem id. */ 149 /* for backward compatibility */ 150 STAC_MACMINI, 151 STAC_MACBOOK, 152 STAC_MACBOOK_PRO_V1, 153 STAC_MACBOOK_PRO_V2, 154 STAC_IMAC_INTEL, 155 STAC_IMAC_INTEL_20, 156 STAC_ECS_202, 157 STAC_922X_DELL_D81, 158 STAC_922X_DELL_D82, 159 STAC_922X_DELL_M81, 160 STAC_922X_DELL_M82, 161 STAC_922X_MODELS 162 }; 163 164 enum { 165 STAC_927X_AUTO, 166 STAC_D965_REF_NO_JD, /* no jack-detection */ 167 STAC_D965_REF, 168 STAC_D965_3ST, 169 STAC_D965_5ST, 170 STAC_D965_5ST_NO_FP, 171 STAC_DELL_3ST, 172 STAC_DELL_BIOS, 173 STAC_927X_VOLKNOB, 174 STAC_927X_MODELS 175 }; 176 177 enum { 178 STAC_9872_AUTO, 179 STAC_9872_VAIO, 180 STAC_9872_MODELS 181 }; 182 183 struct sigmatel_mic_route { 184 hda_nid_t pin; 185 signed char mux_idx; 186 signed char dmux_idx; 187 }; 188 189 #define MAX_PINS_NUM 16 190 #define MAX_ADCS_NUM 4 191 #define MAX_DMICS_NUM 4 192 193 struct sigmatel_spec { 194 struct snd_kcontrol_new *mixers[4]; 195 unsigned int num_mixers; 196 197 int board_config; 198 unsigned int eapd_switch: 1; 199 unsigned int surr_switch: 1; 200 unsigned int alt_switch: 1; 201 unsigned int hp_detect: 1; 202 unsigned int spdif_mute: 1; 203 unsigned int check_volume_offset:1; 204 unsigned int auto_mic:1; 205 unsigned int linear_tone_beep:1; 206 207 /* gpio lines */ 208 unsigned int eapd_mask; 209 unsigned int gpio_mask; 210 unsigned int gpio_dir; 211 unsigned int gpio_data; 212 unsigned int gpio_mute; 213 unsigned int gpio_led; 214 unsigned int gpio_led_polarity; 215 unsigned int vref_mute_led_nid; /* pin NID for mute-LED vref control */ 216 unsigned int vref_led; 217 218 /* stream */ 219 unsigned int stream_delay; 220 221 /* analog loopback */ 222 const struct snd_kcontrol_new *aloopback_ctl; 223 unsigned char aloopback_mask; 224 unsigned char aloopback_shift; 225 226 /* power management */ 227 unsigned int power_map_bits; 228 unsigned int num_pwrs; 229 const hda_nid_t *pwr_nids; 230 const hda_nid_t *dac_list; 231 232 /* playback */ 233 struct hda_input_mux *mono_mux; 234 unsigned int cur_mmux; 235 struct hda_multi_out multiout; 236 hda_nid_t dac_nids[5]; 237 hda_nid_t hp_dacs[5]; 238 hda_nid_t speaker_dacs[5]; 239 240 int volume_offset; 241 242 /* capture */ 243 const hda_nid_t *adc_nids; 244 unsigned int num_adcs; 245 const hda_nid_t *mux_nids; 246 unsigned int num_muxes; 247 const hda_nid_t *dmic_nids; 248 unsigned int num_dmics; 249 const hda_nid_t *dmux_nids; 250 unsigned int num_dmuxes; 251 const hda_nid_t *smux_nids; 252 unsigned int num_smuxes; 253 unsigned int num_analog_muxes; 254 255 const unsigned long *capvols; /* amp-volume attr: HDA_COMPOSE_AMP_VAL() */ 256 const unsigned long *capsws; /* amp-mute attr: HDA_COMPOSE_AMP_VAL() */ 257 unsigned int num_caps; /* number of capture volume/switch elements */ 258 259 struct sigmatel_mic_route ext_mic; 260 struct sigmatel_mic_route int_mic; 261 struct sigmatel_mic_route dock_mic; 262 263 const char * const *spdif_labels; 264 265 hda_nid_t dig_in_nid; 266 hda_nid_t mono_nid; 267 hda_nid_t anabeep_nid; 268 hda_nid_t digbeep_nid; 269 270 /* pin widgets */ 271 const hda_nid_t *pin_nids; 272 unsigned int num_pins; 273 274 /* codec specific stuff */ 275 const struct hda_verb *init; 276 const struct snd_kcontrol_new *mixer; 277 278 /* capture source */ 279 struct hda_input_mux *dinput_mux; 280 unsigned int cur_dmux[2]; 281 struct hda_input_mux *input_mux; 282 unsigned int cur_mux[3]; 283 struct hda_input_mux *sinput_mux; 284 unsigned int cur_smux[2]; 285 unsigned int cur_amux; 286 hda_nid_t *amp_nids; 287 unsigned int powerdown_adcs; 288 289 /* i/o switches */ 290 unsigned int io_switch[2]; 291 unsigned int clfe_swap; 292 hda_nid_t line_switch; /* shared line-in for input and output */ 293 hda_nid_t mic_switch; /* shared mic-in for input and output */ 294 hda_nid_t hp_switch; /* NID of HP as line-out */ 295 unsigned int aloopback; 296 297 struct hda_pcm pcm_rec[2]; /* PCM information */ 298 299 /* dynamic controls and input_mux */ 300 struct auto_pin_cfg autocfg; 301 struct snd_array kctls; 302 struct hda_input_mux private_dimux; 303 struct hda_input_mux private_imux; 304 struct hda_input_mux private_smux; 305 struct hda_input_mux private_mono_mux; 306 307 /* auto spec */ 308 unsigned auto_pin_cnt; 309 hda_nid_t auto_pin_nids[MAX_PINS_NUM]; 310 unsigned auto_adc_cnt; 311 hda_nid_t auto_adc_nids[MAX_ADCS_NUM]; 312 hda_nid_t auto_mux_nids[MAX_ADCS_NUM]; 313 hda_nid_t auto_dmux_nids[MAX_ADCS_NUM]; 314 unsigned long auto_capvols[MAX_ADCS_NUM]; 315 unsigned auto_dmic_cnt; 316 hda_nid_t auto_dmic_nids[MAX_DMICS_NUM]; 317 318 struct hda_vmaster_mute_hook vmaster_mute; 319 }; 320 321 #define AC_VERB_IDT_SET_POWER_MAP 0x7ec 322 #define AC_VERB_IDT_GET_POWER_MAP 0xfec 323 324 static const hda_nid_t stac9200_adc_nids[1] = { 325 0x03, 326 }; 327 328 static const hda_nid_t stac9200_mux_nids[1] = { 329 0x0c, 330 }; 331 332 static const hda_nid_t stac9200_dac_nids[1] = { 333 0x02, 334 }; 335 336 static const hda_nid_t stac92hd73xx_pwr_nids[8] = { 337 0x0a, 0x0b, 0x0c, 0xd, 0x0e, 338 0x0f, 0x10, 0x11 339 }; 340 341 static const hda_nid_t stac92hd73xx_slave_dig_outs[2] = { 342 0x26, 0, 343 }; 344 345 static const hda_nid_t stac92hd73xx_adc_nids[2] = { 346 0x1a, 0x1b 347 }; 348 349 #define STAC92HD73XX_NUM_DMICS 2 350 static const hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = { 351 0x13, 0x14, 0 352 }; 353 354 #define STAC92HD73_DAC_COUNT 5 355 356 static const hda_nid_t stac92hd73xx_mux_nids[2] = { 357 0x20, 0x21, 358 }; 359 360 static const hda_nid_t stac92hd73xx_dmux_nids[2] = { 361 0x20, 0x21, 362 }; 363 364 static const hda_nid_t stac92hd73xx_smux_nids[2] = { 365 0x22, 0x23, 366 }; 367 368 #define STAC92HD73XX_NUM_CAPS 2 369 static const unsigned long stac92hd73xx_capvols[] = { 370 HDA_COMPOSE_AMP_VAL(0x20, 3, 0, HDA_OUTPUT), 371 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT), 372 }; 373 #define stac92hd73xx_capsws stac92hd73xx_capvols 374 375 #define STAC92HD83_DAC_COUNT 3 376 377 static const hda_nid_t stac92hd83xxx_pwr_nids[7] = { 378 0x0a, 0x0b, 0x0c, 0xd, 0x0e, 379 0x0f, 0x10 380 }; 381 382 static const hda_nid_t stac92hd83xxx_slave_dig_outs[2] = { 383 0x1e, 0, 384 }; 385 386 static const hda_nid_t stac92hd83xxx_dmic_nids[] = { 387 0x11, 0x20, 388 }; 389 390 static const hda_nid_t stac92hd71bxx_pwr_nids[3] = { 391 0x0a, 0x0d, 0x0f 392 }; 393 394 static const hda_nid_t stac92hd71bxx_adc_nids[2] = { 395 0x12, 0x13, 396 }; 397 398 static const hda_nid_t stac92hd71bxx_mux_nids[2] = { 399 0x1a, 0x1b 400 }; 401 402 static const hda_nid_t stac92hd71bxx_dmux_nids[2] = { 403 0x1c, 0x1d, 404 }; 405 406 static const hda_nid_t stac92hd71bxx_smux_nids[2] = { 407 0x24, 0x25, 408 }; 409 410 #define STAC92HD71BXX_NUM_DMICS 2 411 static const hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = { 412 0x18, 0x19, 0 413 }; 414 415 static const hda_nid_t stac92hd71bxx_dmic_5port_nids[STAC92HD71BXX_NUM_DMICS] = { 416 0x18, 0 417 }; 418 419 static const hda_nid_t stac92hd71bxx_slave_dig_outs[2] = { 420 0x22, 0 421 }; 422 423 #define STAC92HD71BXX_NUM_CAPS 2 424 static const unsigned long stac92hd71bxx_capvols[] = { 425 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT), 426 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT), 427 }; 428 #define stac92hd71bxx_capsws stac92hd71bxx_capvols 429 430 static const hda_nid_t stac925x_adc_nids[1] = { 431 0x03, 432 }; 433 434 static const hda_nid_t stac925x_mux_nids[1] = { 435 0x0f, 436 }; 437 438 static const hda_nid_t stac925x_dac_nids[1] = { 439 0x02, 440 }; 441 442 #define STAC925X_NUM_DMICS 1 443 static const hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = { 444 0x15, 0 445 }; 446 447 static const hda_nid_t stac925x_dmux_nids[1] = { 448 0x14, 449 }; 450 451 static const unsigned long stac925x_capvols[] = { 452 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT), 453 }; 454 static const unsigned long stac925x_capsws[] = { 455 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT), 456 }; 457 458 static const hda_nid_t stac922x_adc_nids[2] = { 459 0x06, 0x07, 460 }; 461 462 static const hda_nid_t stac922x_mux_nids[2] = { 463 0x12, 0x13, 464 }; 465 466 #define STAC922X_NUM_CAPS 2 467 static const unsigned long stac922x_capvols[] = { 468 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_INPUT), 469 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT), 470 }; 471 #define stac922x_capsws stac922x_capvols 472 473 static const hda_nid_t stac927x_slave_dig_outs[2] = { 474 0x1f, 0, 475 }; 476 477 static const hda_nid_t stac927x_adc_nids[3] = { 478 0x07, 0x08, 0x09 479 }; 480 481 static const hda_nid_t stac927x_mux_nids[3] = { 482 0x15, 0x16, 0x17 483 }; 484 485 static const hda_nid_t stac927x_smux_nids[1] = { 486 0x21, 487 }; 488 489 static const hda_nid_t stac927x_dac_nids[6] = { 490 0x02, 0x03, 0x04, 0x05, 0x06, 0 491 }; 492 493 static const hda_nid_t stac927x_dmux_nids[1] = { 494 0x1b, 495 }; 496 497 #define STAC927X_NUM_DMICS 2 498 static const hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = { 499 0x13, 0x14, 0 500 }; 501 502 #define STAC927X_NUM_CAPS 3 503 static const unsigned long stac927x_capvols[] = { 504 HDA_COMPOSE_AMP_VAL(0x18, 3, 0, HDA_INPUT), 505 HDA_COMPOSE_AMP_VAL(0x19, 3, 0, HDA_INPUT), 506 HDA_COMPOSE_AMP_VAL(0x1a, 3, 0, HDA_INPUT), 507 }; 508 static const unsigned long stac927x_capsws[] = { 509 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT), 510 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_OUTPUT), 511 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT), 512 }; 513 514 static const char * const stac927x_spdif_labels[5] = { 515 "Digital Playback", "ADAT", "Analog Mux 1", 516 "Analog Mux 2", "Analog Mux 3" 517 }; 518 519 static const hda_nid_t stac9205_adc_nids[2] = { 520 0x12, 0x13 521 }; 522 523 static const hda_nid_t stac9205_mux_nids[2] = { 524 0x19, 0x1a 525 }; 526 527 static const hda_nid_t stac9205_dmux_nids[1] = { 528 0x1d, 529 }; 530 531 static const hda_nid_t stac9205_smux_nids[1] = { 532 0x21, 533 }; 534 535 #define STAC9205_NUM_DMICS 2 536 static const hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = { 537 0x17, 0x18, 0 538 }; 539 540 #define STAC9205_NUM_CAPS 2 541 static const unsigned long stac9205_capvols[] = { 542 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_INPUT), 543 HDA_COMPOSE_AMP_VAL(0x1c, 3, 0, HDA_INPUT), 544 }; 545 static const unsigned long stac9205_capsws[] = { 546 HDA_COMPOSE_AMP_VAL(0x1d, 3, 0, HDA_OUTPUT), 547 HDA_COMPOSE_AMP_VAL(0x1e, 3, 0, HDA_OUTPUT), 548 }; 549 550 static const hda_nid_t stac9200_pin_nids[8] = { 551 0x08, 0x09, 0x0d, 0x0e, 552 0x0f, 0x10, 0x11, 0x12, 553 }; 554 555 static const hda_nid_t stac925x_pin_nids[8] = { 556 0x07, 0x08, 0x0a, 0x0b, 557 0x0c, 0x0d, 0x10, 0x11, 558 }; 559 560 static const hda_nid_t stac922x_pin_nids[10] = { 561 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 562 0x0f, 0x10, 0x11, 0x15, 0x1b, 563 }; 564 565 static const hda_nid_t stac92hd73xx_pin_nids[13] = { 566 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 567 0x0f, 0x10, 0x11, 0x12, 0x13, 568 0x14, 0x22, 0x23 569 }; 570 571 #define STAC92HD71BXX_NUM_PINS 13 572 static const hda_nid_t stac92hd71bxx_pin_nids_4port[STAC92HD71BXX_NUM_PINS] = { 573 0x0a, 0x0b, 0x0c, 0x0d, 0x00, 574 0x00, 0x14, 0x18, 0x19, 0x1e, 575 0x1f, 0x20, 0x27 576 }; 577 static const hda_nid_t stac92hd71bxx_pin_nids_6port[STAC92HD71BXX_NUM_PINS] = { 578 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 579 0x0f, 0x14, 0x18, 0x19, 0x1e, 580 0x1f, 0x20, 0x27 581 }; 582 583 static const hda_nid_t stac927x_pin_nids[14] = { 584 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 585 0x0f, 0x10, 0x11, 0x12, 0x13, 586 0x14, 0x21, 0x22, 0x23, 587 }; 588 589 static const hda_nid_t stac9205_pin_nids[12] = { 590 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 591 0x0f, 0x14, 0x16, 0x17, 0x18, 592 0x21, 0x22, 593 }; 594 595 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol, 596 struct snd_ctl_elem_info *uinfo) 597 { 598 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 599 struct sigmatel_spec *spec = codec->spec; 600 return snd_hda_input_mux_info(spec->dinput_mux, uinfo); 601 } 602 603 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol, 604 struct snd_ctl_elem_value *ucontrol) 605 { 606 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 607 struct sigmatel_spec *spec = codec->spec; 608 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 609 610 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx]; 611 return 0; 612 } 613 614 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol, 615 struct snd_ctl_elem_value *ucontrol) 616 { 617 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 618 struct sigmatel_spec *spec = codec->spec; 619 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 620 621 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol, 622 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]); 623 } 624 625 static int stac92xx_smux_enum_info(struct snd_kcontrol *kcontrol, 626 struct snd_ctl_elem_info *uinfo) 627 { 628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 629 struct sigmatel_spec *spec = codec->spec; 630 return snd_hda_input_mux_info(spec->sinput_mux, uinfo); 631 } 632 633 static int stac92xx_smux_enum_get(struct snd_kcontrol *kcontrol, 634 struct snd_ctl_elem_value *ucontrol) 635 { 636 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 637 struct sigmatel_spec *spec = codec->spec; 638 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 639 640 ucontrol->value.enumerated.item[0] = spec->cur_smux[smux_idx]; 641 return 0; 642 } 643 644 static int stac92xx_smux_enum_put(struct snd_kcontrol *kcontrol, 645 struct snd_ctl_elem_value *ucontrol) 646 { 647 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 648 struct sigmatel_spec *spec = codec->spec; 649 struct hda_input_mux *smux = &spec->private_smux; 650 unsigned int smux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 651 int err, val; 652 hda_nid_t nid; 653 654 err = snd_hda_input_mux_put(codec, spec->sinput_mux, ucontrol, 655 spec->smux_nids[smux_idx], &spec->cur_smux[smux_idx]); 656 if (err < 0) 657 return err; 658 659 if (spec->spdif_mute) { 660 if (smux_idx == 0) 661 nid = spec->multiout.dig_out_nid; 662 else 663 nid = codec->slave_dig_outs[smux_idx - 1]; 664 if (spec->cur_smux[smux_idx] == smux->num_items - 1) 665 val = HDA_AMP_MUTE; 666 else 667 val = 0; 668 /* un/mute SPDIF out */ 669 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0, 670 HDA_AMP_MUTE, val); 671 } 672 return 0; 673 } 674 675 static int stac_vrefout_set(struct hda_codec *codec, 676 hda_nid_t nid, unsigned int new_vref) 677 { 678 int error, pinctl; 679 680 snd_printdd("%s, nid %x ctl %x\n", __func__, nid, new_vref); 681 pinctl = snd_hda_codec_read(codec, nid, 0, 682 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 683 684 if (pinctl < 0) 685 return pinctl; 686 687 pinctl &= 0xff; 688 pinctl &= ~AC_PINCTL_VREFEN; 689 pinctl |= (new_vref & AC_PINCTL_VREFEN); 690 691 error = snd_hda_set_pin_ctl_cache(codec, nid, pinctl); 692 if (error < 0) 693 return error; 694 695 return 1; 696 } 697 698 static unsigned int stac92xx_vref_set(struct hda_codec *codec, 699 hda_nid_t nid, unsigned int new_vref) 700 { 701 int error; 702 unsigned int pincfg; 703 pincfg = snd_hda_codec_read(codec, nid, 0, 704 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 705 706 pincfg &= 0xff; 707 pincfg &= ~(AC_PINCTL_VREFEN | AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 708 pincfg |= new_vref; 709 710 if (new_vref == AC_PINCTL_VREF_HIZ) 711 pincfg |= AC_PINCTL_OUT_EN; 712 else 713 pincfg |= AC_PINCTL_IN_EN; 714 715 error = snd_hda_set_pin_ctl_cache(codec, nid, pincfg); 716 if (error < 0) 717 return error; 718 else 719 return 1; 720 } 721 722 static unsigned int stac92xx_vref_get(struct hda_codec *codec, hda_nid_t nid) 723 { 724 unsigned int vref; 725 vref = snd_hda_codec_read(codec, nid, 0, 726 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 727 vref &= AC_PINCTL_VREFEN; 728 return vref; 729 } 730 731 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 732 { 733 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 734 struct sigmatel_spec *spec = codec->spec; 735 return snd_hda_input_mux_info(spec->input_mux, uinfo); 736 } 737 738 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 739 { 740 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 741 struct sigmatel_spec *spec = codec->spec; 742 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 743 744 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 745 return 0; 746 } 747 748 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 749 { 750 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 751 struct sigmatel_spec *spec = codec->spec; 752 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 753 const struct hda_input_mux *imux = spec->input_mux; 754 unsigned int idx, prev_idx, didx; 755 756 idx = ucontrol->value.enumerated.item[0]; 757 if (idx >= imux->num_items) 758 idx = imux->num_items - 1; 759 prev_idx = spec->cur_mux[adc_idx]; 760 if (prev_idx == idx) 761 return 0; 762 if (idx < spec->num_analog_muxes) { 763 snd_hda_codec_write_cache(codec, spec->mux_nids[adc_idx], 0, 764 AC_VERB_SET_CONNECT_SEL, 765 imux->items[idx].index); 766 if (prev_idx >= spec->num_analog_muxes && 767 spec->mux_nids[adc_idx] != spec->dmux_nids[adc_idx]) { 768 imux = spec->dinput_mux; 769 /* 0 = analog */ 770 snd_hda_codec_write_cache(codec, 771 spec->dmux_nids[adc_idx], 0, 772 AC_VERB_SET_CONNECT_SEL, 773 imux->items[0].index); 774 } 775 } else { 776 imux = spec->dinput_mux; 777 /* first dimux item is hardcoded to select analog imux, 778 * so lets skip it 779 */ 780 didx = idx - spec->num_analog_muxes + 1; 781 snd_hda_codec_write_cache(codec, spec->dmux_nids[adc_idx], 0, 782 AC_VERB_SET_CONNECT_SEL, 783 imux->items[didx].index); 784 } 785 spec->cur_mux[adc_idx] = idx; 786 return 1; 787 } 788 789 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol, 790 struct snd_ctl_elem_info *uinfo) 791 { 792 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 793 struct sigmatel_spec *spec = codec->spec; 794 return snd_hda_input_mux_info(spec->mono_mux, uinfo); 795 } 796 797 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol, 798 struct snd_ctl_elem_value *ucontrol) 799 { 800 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 801 struct sigmatel_spec *spec = codec->spec; 802 803 ucontrol->value.enumerated.item[0] = spec->cur_mmux; 804 return 0; 805 } 806 807 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol, 808 struct snd_ctl_elem_value *ucontrol) 809 { 810 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 811 struct sigmatel_spec *spec = codec->spec; 812 813 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol, 814 spec->mono_nid, &spec->cur_mmux); 815 } 816 817 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info 818 819 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol, 820 struct snd_ctl_elem_value *ucontrol) 821 { 822 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 823 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 824 struct sigmatel_spec *spec = codec->spec; 825 826 ucontrol->value.integer.value[0] = !!(spec->aloopback & 827 (spec->aloopback_mask << idx)); 828 return 0; 829 } 830 831 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol, 832 struct snd_ctl_elem_value *ucontrol) 833 { 834 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 835 struct sigmatel_spec *spec = codec->spec; 836 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 837 unsigned int dac_mode; 838 unsigned int val, idx_val; 839 840 idx_val = spec->aloopback_mask << idx; 841 if (ucontrol->value.integer.value[0]) 842 val = spec->aloopback | idx_val; 843 else 844 val = spec->aloopback & ~idx_val; 845 if (spec->aloopback == val) 846 return 0; 847 848 spec->aloopback = val; 849 850 /* Only return the bits defined by the shift value of the 851 * first two bytes of the mask 852 */ 853 dac_mode = snd_hda_codec_read(codec, codec->afg, 0, 854 kcontrol->private_value & 0xFFFF, 0x0); 855 dac_mode >>= spec->aloopback_shift; 856 857 if (spec->aloopback & idx_val) { 858 snd_hda_power_up(codec); 859 dac_mode |= idx_val; 860 } else { 861 snd_hda_power_down(codec); 862 dac_mode &= ~idx_val; 863 } 864 865 snd_hda_codec_write_cache(codec, codec->afg, 0, 866 kcontrol->private_value >> 16, dac_mode); 867 868 return 1; 869 } 870 871 static const struct hda_verb stac9200_core_init[] = { 872 /* set dac0mux for dac converter */ 873 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 874 {} 875 }; 876 877 static const struct hda_verb stac9200_eapd_init[] = { 878 /* set dac0mux for dac converter */ 879 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 880 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 881 {} 882 }; 883 884 static const struct hda_verb dell_eq_core_init[] = { 885 /* set master volume to max value without distortion 886 * and direct control */ 887 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec}, 888 {} 889 }; 890 891 static const struct hda_verb stac92hd73xx_core_init[] = { 892 /* set master volume and direct control */ 893 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 894 {} 895 }; 896 897 static const struct hda_verb stac92hd83xxx_core_init[] = { 898 /* power state controls amps */ 899 { 0x01, AC_VERB_SET_EAPD, 1 << 2}, 900 {} 901 }; 902 903 static const struct hda_verb stac92hd83xxx_hp_zephyr_init[] = { 904 { 0x22, 0x785, 0x43 }, 905 { 0x22, 0x782, 0xe0 }, 906 { 0x22, 0x795, 0x00 }, 907 {} 908 }; 909 910 static const struct hda_verb stac92hd71bxx_core_init[] = { 911 /* set master volume and direct control */ 912 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 913 {} 914 }; 915 916 static const struct hda_verb stac92hd71bxx_unmute_core_init[] = { 917 /* unmute right and left channels for nodes 0x0f, 0xa, 0x0d */ 918 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 919 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 920 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 921 {} 922 }; 923 924 static const struct hda_verb stac925x_core_init[] = { 925 /* set dac0mux for dac converter */ 926 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00}, 927 /* mute the master volume */ 928 { 0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE }, 929 {} 930 }; 931 932 static const struct hda_verb stac922x_core_init[] = { 933 /* set master volume and direct control */ 934 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 935 {} 936 }; 937 938 static const struct hda_verb d965_core_init[] = { 939 /* set master volume and direct control */ 940 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 941 /* unmute node 0x1b */ 942 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 943 /* select node 0x03 as DAC */ 944 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01}, 945 {} 946 }; 947 948 static const struct hda_verb dell_3st_core_init[] = { 949 /* don't set delta bit */ 950 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f}, 951 /* unmute node 0x1b */ 952 {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 953 /* select node 0x03 as DAC */ 954 {0x0b, AC_VERB_SET_CONNECT_SEL, 0x01}, 955 {} 956 }; 957 958 static const struct hda_verb stac927x_core_init[] = { 959 /* set master volume and direct control */ 960 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 961 /* enable analog pc beep path */ 962 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5}, 963 {} 964 }; 965 966 static const struct hda_verb stac927x_volknob_core_init[] = { 967 /* don't set delta bit */ 968 {0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0x7f}, 969 /* enable analog pc beep path */ 970 {0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5}, 971 {} 972 }; 973 974 static const struct hda_verb stac9205_core_init[] = { 975 /* set master volume and direct control */ 976 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 977 /* enable analog pc beep path */ 978 { 0x01, AC_VERB_SET_DIGI_CONVERT_2, 1 << 5}, 979 {} 980 }; 981 982 #define STAC_MONO_MUX \ 983 { \ 984 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 985 .name = "Mono Mux", \ 986 .count = 1, \ 987 .info = stac92xx_mono_mux_enum_info, \ 988 .get = stac92xx_mono_mux_enum_get, \ 989 .put = stac92xx_mono_mux_enum_put, \ 990 } 991 992 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \ 993 { \ 994 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 995 .name = "Analog Loopback", \ 996 .count = cnt, \ 997 .info = stac92xx_aloopback_info, \ 998 .get = stac92xx_aloopback_get, \ 999 .put = stac92xx_aloopback_put, \ 1000 .private_value = verb_read | (verb_write << 16), \ 1001 } 1002 1003 #define DC_BIAS(xname, idx, nid) \ 1004 { \ 1005 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 1006 .name = xname, \ 1007 .index = idx, \ 1008 .info = stac92xx_dc_bias_info, \ 1009 .get = stac92xx_dc_bias_get, \ 1010 .put = stac92xx_dc_bias_put, \ 1011 .private_value = nid, \ 1012 } 1013 1014 static const struct snd_kcontrol_new stac9200_mixer[] = { 1015 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xb, 0, HDA_OUTPUT), 1016 HDA_CODEC_MUTE("PCM Playback Switch", 0xb, 0, HDA_OUTPUT), 1017 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT), 1018 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT), 1019 { } /* end */ 1020 }; 1021 1022 static const struct snd_kcontrol_new stac92hd73xx_6ch_loopback[] = { 1023 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3), 1024 {} 1025 }; 1026 1027 static const struct snd_kcontrol_new stac92hd73xx_8ch_loopback[] = { 1028 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4), 1029 {} 1030 }; 1031 1032 static const struct snd_kcontrol_new stac92hd73xx_10ch_loopback[] = { 1033 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5), 1034 {} 1035 }; 1036 1037 1038 static const struct snd_kcontrol_new stac92hd71bxx_loopback[] = { 1039 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2) 1040 }; 1041 1042 static const struct snd_kcontrol_new stac925x_mixer[] = { 1043 HDA_CODEC_VOLUME_MIN_MUTE("PCM Playback Volume", 0xe, 0, HDA_OUTPUT), 1044 HDA_CODEC_MUTE("PCM Playback Switch", 0x0e, 0, HDA_OUTPUT), 1045 { } /* end */ 1046 }; 1047 1048 static const struct snd_kcontrol_new stac9205_loopback[] = { 1049 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1), 1050 {} 1051 }; 1052 1053 static const struct snd_kcontrol_new stac927x_loopback[] = { 1054 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1), 1055 {} 1056 }; 1057 1058 static struct snd_kcontrol_new stac_dmux_mixer = { 1059 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1060 .name = "Digital Input Source", 1061 /* count set later */ 1062 .info = stac92xx_dmux_enum_info, 1063 .get = stac92xx_dmux_enum_get, 1064 .put = stac92xx_dmux_enum_put, 1065 }; 1066 1067 static struct snd_kcontrol_new stac_smux_mixer = { 1068 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 1069 .name = "IEC958 Playback Source", 1070 /* count set later */ 1071 .info = stac92xx_smux_enum_info, 1072 .get = stac92xx_smux_enum_get, 1073 .put = stac92xx_smux_enum_put, 1074 }; 1075 1076 static const char * const slave_pfxs[] = { 1077 "Front", "Surround", "Center", "LFE", "Side", 1078 "Headphone", "Speaker", "IEC958", 1079 NULL 1080 }; 1081 1082 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled); 1083 1084 static void stac92xx_vmaster_hook(void *private_data, int val) 1085 { 1086 stac92xx_update_led_status(private_data, val); 1087 } 1088 1089 static void stac92xx_free_kctls(struct hda_codec *codec); 1090 1091 static int stac92xx_build_controls(struct hda_codec *codec) 1092 { 1093 struct sigmatel_spec *spec = codec->spec; 1094 unsigned int vmaster_tlv[4]; 1095 int err; 1096 int i; 1097 1098 if (spec->mixer) { 1099 err = snd_hda_add_new_ctls(codec, spec->mixer); 1100 if (err < 0) 1101 return err; 1102 } 1103 1104 for (i = 0; i < spec->num_mixers; i++) { 1105 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 1106 if (err < 0) 1107 return err; 1108 } 1109 if (!spec->auto_mic && spec->num_dmuxes > 0 && 1110 snd_hda_get_bool_hint(codec, "separate_dmux") == 1) { 1111 stac_dmux_mixer.count = spec->num_dmuxes; 1112 err = snd_hda_ctl_add(codec, 0, 1113 snd_ctl_new1(&stac_dmux_mixer, codec)); 1114 if (err < 0) 1115 return err; 1116 } 1117 if (spec->num_smuxes > 0) { 1118 int wcaps = get_wcaps(codec, spec->multiout.dig_out_nid); 1119 struct hda_input_mux *smux = &spec->private_smux; 1120 /* check for mute support on SPDIF out */ 1121 if (wcaps & AC_WCAP_OUT_AMP) { 1122 snd_hda_add_imux_item(smux, "Off", 0, NULL); 1123 spec->spdif_mute = 1; 1124 } 1125 stac_smux_mixer.count = spec->num_smuxes; 1126 err = snd_hda_ctl_add(codec, 0, 1127 snd_ctl_new1(&stac_smux_mixer, codec)); 1128 if (err < 0) 1129 return err; 1130 } 1131 1132 if (spec->multiout.dig_out_nid) { 1133 err = snd_hda_create_spdif_out_ctls(codec, 1134 spec->multiout.dig_out_nid, 1135 spec->multiout.dig_out_nid); 1136 if (err < 0) 1137 return err; 1138 err = snd_hda_create_spdif_share_sw(codec, 1139 &spec->multiout); 1140 if (err < 0) 1141 return err; 1142 spec->multiout.share_spdif = 1; 1143 } 1144 if (spec->dig_in_nid && !(spec->gpio_dir & 0x01)) { 1145 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 1146 if (err < 0) 1147 return err; 1148 } 1149 1150 /* if we have no master control, let's create it */ 1151 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0], 1152 HDA_OUTPUT, vmaster_tlv); 1153 /* correct volume offset */ 1154 vmaster_tlv[2] += vmaster_tlv[3] * spec->volume_offset; 1155 /* minimum value is actually mute */ 1156 vmaster_tlv[3] |= TLV_DB_SCALE_MUTE; 1157 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 1158 vmaster_tlv, slave_pfxs, 1159 "Playback Volume"); 1160 if (err < 0) 1161 return err; 1162 1163 err = __snd_hda_add_vmaster(codec, "Master Playback Switch", 1164 NULL, slave_pfxs, 1165 "Playback Switch", true, 1166 &spec->vmaster_mute.sw_kctl); 1167 if (err < 0) 1168 return err; 1169 1170 if (spec->gpio_led) { 1171 spec->vmaster_mute.hook = stac92xx_vmaster_hook; 1172 err = snd_hda_add_vmaster_hook(codec, &spec->vmaster_mute, true); 1173 if (err < 0) 1174 return err; 1175 } 1176 1177 if (spec->aloopback_ctl && 1178 snd_hda_get_bool_hint(codec, "loopback") == 1) { 1179 err = snd_hda_add_new_ctls(codec, spec->aloopback_ctl); 1180 if (err < 0) 1181 return err; 1182 } 1183 1184 stac92xx_free_kctls(codec); /* no longer needed */ 1185 1186 err = snd_hda_jack_add_kctls(codec, &spec->autocfg); 1187 if (err < 0) 1188 return err; 1189 1190 return 0; 1191 } 1192 1193 static const unsigned int ref9200_pin_configs[8] = { 1194 0x01c47010, 0x01447010, 0x0221401f, 0x01114010, 1195 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, 1196 }; 1197 1198 static const unsigned int gateway9200_m4_pin_configs[8] = { 1199 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010, 1200 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3, 1201 }; 1202 static const unsigned int gateway9200_m4_2_pin_configs[8] = { 1203 0x400000fe, 0x404500f4, 0x400100f0, 0x90110010, 1204 0x400100f1, 0x02a1902e, 0x500000f2, 0x500000f3, 1205 }; 1206 1207 /* 1208 STAC 9200 pin configs for 1209 102801A8 1210 102801DE 1211 102801E8 1212 */ 1213 static const unsigned int dell9200_d21_pin_configs[8] = { 1214 0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 1215 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, 1216 }; 1217 1218 /* 1219 STAC 9200 pin configs for 1220 102801C0 1221 102801C1 1222 */ 1223 static const unsigned int dell9200_d22_pin_configs[8] = { 1224 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 1225 0x01813020, 0x02a19021, 0x90100140, 0x400001f2, 1226 }; 1227 1228 /* 1229 STAC 9200 pin configs for 1230 102801C4 (Dell Dimension E310) 1231 102801C5 1232 102801C7 1233 102801D9 1234 102801DA 1235 102801E3 1236 */ 1237 static const unsigned int dell9200_d23_pin_configs[8] = { 1238 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 1239 0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 1240 }; 1241 1242 1243 /* 1244 STAC 9200-32 pin configs for 1245 102801B5 (Dell Inspiron 630m) 1246 102801D8 (Dell Inspiron 640m) 1247 */ 1248 static const unsigned int dell9200_m21_pin_configs[8] = { 1249 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310, 1250 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd, 1251 }; 1252 1253 /* 1254 STAC 9200-32 pin configs for 1255 102801C2 (Dell Latitude D620) 1256 102801C8 1257 102801CC (Dell Latitude D820) 1258 102801D4 1259 102801D6 1260 */ 1261 static const unsigned int dell9200_m22_pin_configs[8] = { 1262 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 1263 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc, 1264 }; 1265 1266 /* 1267 STAC 9200-32 pin configs for 1268 102801CE (Dell XPS M1710) 1269 102801CF (Dell Precision M90) 1270 */ 1271 static const unsigned int dell9200_m23_pin_configs[8] = { 1272 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310, 1273 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc, 1274 }; 1275 1276 /* 1277 STAC 9200-32 pin configs for 1278 102801C9 1279 102801CA 1280 102801CB (Dell Latitude 120L) 1281 102801D3 1282 */ 1283 static const unsigned int dell9200_m24_pin_configs[8] = { 1284 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 1285 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 1286 }; 1287 1288 /* 1289 STAC 9200-32 pin configs for 1290 102801BD (Dell Inspiron E1505n) 1291 102801EE 1292 102801EF 1293 */ 1294 static const unsigned int dell9200_m25_pin_configs[8] = { 1295 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 1296 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd, 1297 }; 1298 1299 /* 1300 STAC 9200-32 pin configs for 1301 102801F5 (Dell Inspiron 1501) 1302 102801F6 1303 */ 1304 static const unsigned int dell9200_m26_pin_configs[8] = { 1305 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 1306 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe, 1307 }; 1308 1309 /* 1310 STAC 9200-32 1311 102801CD (Dell Inspiron E1705/9400) 1312 */ 1313 static const unsigned int dell9200_m27_pin_configs[8] = { 1314 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 1315 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc, 1316 }; 1317 1318 static const unsigned int oqo9200_pin_configs[8] = { 1319 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210, 1320 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3, 1321 }; 1322 1323 1324 static const unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = { 1325 [STAC_REF] = ref9200_pin_configs, 1326 [STAC_9200_OQO] = oqo9200_pin_configs, 1327 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs, 1328 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs, 1329 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs, 1330 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs, 1331 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs, 1332 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs, 1333 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs, 1334 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs, 1335 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs, 1336 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs, 1337 [STAC_9200_M4] = gateway9200_m4_pin_configs, 1338 [STAC_9200_M4_2] = gateway9200_m4_2_pin_configs, 1339 [STAC_9200_PANASONIC] = ref9200_pin_configs, 1340 }; 1341 1342 static const char * const stac9200_models[STAC_9200_MODELS] = { 1343 [STAC_AUTO] = "auto", 1344 [STAC_REF] = "ref", 1345 [STAC_9200_OQO] = "oqo", 1346 [STAC_9200_DELL_D21] = "dell-d21", 1347 [STAC_9200_DELL_D22] = "dell-d22", 1348 [STAC_9200_DELL_D23] = "dell-d23", 1349 [STAC_9200_DELL_M21] = "dell-m21", 1350 [STAC_9200_DELL_M22] = "dell-m22", 1351 [STAC_9200_DELL_M23] = "dell-m23", 1352 [STAC_9200_DELL_M24] = "dell-m24", 1353 [STAC_9200_DELL_M25] = "dell-m25", 1354 [STAC_9200_DELL_M26] = "dell-m26", 1355 [STAC_9200_DELL_M27] = "dell-m27", 1356 [STAC_9200_M4] = "gateway-m4", 1357 [STAC_9200_M4_2] = "gateway-m4-2", 1358 [STAC_9200_PANASONIC] = "panasonic", 1359 }; 1360 1361 static const struct snd_pci_quirk stac9200_cfg_tbl[] = { 1362 /* SigmaTel reference board */ 1363 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1364 "DFI LanParty", STAC_REF), 1365 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 1366 "DFI LanParty", STAC_REF), 1367 /* Dell laptops have BIOS problem */ 1368 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8, 1369 "unknown Dell", STAC_9200_DELL_D21), 1370 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5, 1371 "Dell Inspiron 630m", STAC_9200_DELL_M21), 1372 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd, 1373 "Dell Inspiron E1505n", STAC_9200_DELL_M25), 1374 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0, 1375 "unknown Dell", STAC_9200_DELL_D22), 1376 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1, 1377 "unknown Dell", STAC_9200_DELL_D22), 1378 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2, 1379 "Dell Latitude D620", STAC_9200_DELL_M22), 1380 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5, 1381 "unknown Dell", STAC_9200_DELL_D23), 1382 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7, 1383 "unknown Dell", STAC_9200_DELL_D23), 1384 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8, 1385 "unknown Dell", STAC_9200_DELL_M22), 1386 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9, 1387 "unknown Dell", STAC_9200_DELL_M24), 1388 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca, 1389 "unknown Dell", STAC_9200_DELL_M24), 1390 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb, 1391 "Dell Latitude 120L", STAC_9200_DELL_M24), 1392 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc, 1393 "Dell Latitude D820", STAC_9200_DELL_M22), 1394 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd, 1395 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27), 1396 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce, 1397 "Dell XPS M1710", STAC_9200_DELL_M23), 1398 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf, 1399 "Dell Precision M90", STAC_9200_DELL_M23), 1400 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3, 1401 "unknown Dell", STAC_9200_DELL_M22), 1402 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4, 1403 "unknown Dell", STAC_9200_DELL_M22), 1404 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6, 1405 "unknown Dell", STAC_9200_DELL_M22), 1406 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8, 1407 "Dell Inspiron 640m", STAC_9200_DELL_M21), 1408 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9, 1409 "unknown Dell", STAC_9200_DELL_D23), 1410 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da, 1411 "unknown Dell", STAC_9200_DELL_D23), 1412 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de, 1413 "unknown Dell", STAC_9200_DELL_D21), 1414 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3, 1415 "unknown Dell", STAC_9200_DELL_D23), 1416 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8, 1417 "unknown Dell", STAC_9200_DELL_D21), 1418 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee, 1419 "unknown Dell", STAC_9200_DELL_M25), 1420 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef, 1421 "unknown Dell", STAC_9200_DELL_M25), 1422 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5, 1423 "Dell Inspiron 1501", STAC_9200_DELL_M26), 1424 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6, 1425 "unknown Dell", STAC_9200_DELL_M26), 1426 /* Panasonic */ 1427 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC), 1428 /* Gateway machines needs EAPD to be set on resume */ 1429 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_M4), 1430 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", STAC_9200_M4_2), 1431 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", STAC_9200_M4_2), 1432 /* OQO Mobile */ 1433 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO), 1434 {} /* terminator */ 1435 }; 1436 1437 static const unsigned int ref925x_pin_configs[8] = { 1438 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021, 1439 0x90a70320, 0x02214210, 0x01019020, 0x9033032e, 1440 }; 1441 1442 static const unsigned int stac925xM1_pin_configs[8] = { 1443 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1444 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e, 1445 }; 1446 1447 static const unsigned int stac925xM1_2_pin_configs[8] = { 1448 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1449 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e, 1450 }; 1451 1452 static const unsigned int stac925xM2_pin_configs[8] = { 1453 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1454 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e, 1455 }; 1456 1457 static const unsigned int stac925xM2_2_pin_configs[8] = { 1458 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1459 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e, 1460 }; 1461 1462 static const unsigned int stac925xM3_pin_configs[8] = { 1463 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1464 0x40a000f0, 0x90100210, 0x400003f1, 0x503303f3, 1465 }; 1466 1467 static const unsigned int stac925xM5_pin_configs[8] = { 1468 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1469 0x40a000f0, 0x90100210, 0x400003f1, 0x9033032e, 1470 }; 1471 1472 static const unsigned int stac925xM6_pin_configs[8] = { 1473 0x40c003f4, 0x424503f2, 0x400000f3, 0x02a19020, 1474 0x40a000f0, 0x90100210, 0x400003f1, 0x90330320, 1475 }; 1476 1477 static const unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = { 1478 [STAC_REF] = ref925x_pin_configs, 1479 [STAC_M1] = stac925xM1_pin_configs, 1480 [STAC_M1_2] = stac925xM1_2_pin_configs, 1481 [STAC_M2] = stac925xM2_pin_configs, 1482 [STAC_M2_2] = stac925xM2_2_pin_configs, 1483 [STAC_M3] = stac925xM3_pin_configs, 1484 [STAC_M5] = stac925xM5_pin_configs, 1485 [STAC_M6] = stac925xM6_pin_configs, 1486 }; 1487 1488 static const char * const stac925x_models[STAC_925x_MODELS] = { 1489 [STAC_925x_AUTO] = "auto", 1490 [STAC_REF] = "ref", 1491 [STAC_M1] = "m1", 1492 [STAC_M1_2] = "m1-2", 1493 [STAC_M2] = "m2", 1494 [STAC_M2_2] = "m2-2", 1495 [STAC_M3] = "m3", 1496 [STAC_M5] = "m5", 1497 [STAC_M6] = "m6", 1498 }; 1499 1500 static const struct snd_pci_quirk stac925x_codec_id_cfg_tbl[] = { 1501 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_M2), 1502 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_M5), 1503 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_M1), 1504 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_M2), 1505 SND_PCI_QUIRK(0x107b, 0x0367, "Gateway MX6453", STAC_M1_2), 1506 /* Not sure about the brand name for those */ 1507 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M1), 1508 SND_PCI_QUIRK(0x107b, 0x0507, "Gateway mobile", STAC_M3), 1509 SND_PCI_QUIRK(0x107b, 0x0281, "Gateway mobile", STAC_M6), 1510 SND_PCI_QUIRK(0x107b, 0x0685, "Gateway mobile", STAC_M2_2), 1511 {} /* terminator */ 1512 }; 1513 1514 static const struct snd_pci_quirk stac925x_cfg_tbl[] = { 1515 /* SigmaTel reference board */ 1516 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF), 1517 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, "DFI LanParty", STAC_REF), 1518 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF), 1519 1520 /* Default table for unknown ID */ 1521 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway mobile", STAC_M2_2), 1522 1523 {} /* terminator */ 1524 }; 1525 1526 static const unsigned int ref92hd73xx_pin_configs[13] = { 1527 0x02214030, 0x02a19040, 0x01a19020, 0x02214030, 1528 0x0181302e, 0x01014010, 0x01014020, 0x01014030, 1529 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050, 1530 0x01452050, 1531 }; 1532 1533 static const unsigned int dell_m6_pin_configs[13] = { 1534 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110, 1535 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0, 1536 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0, 1537 0x4f0000f0, 1538 }; 1539 1540 static const unsigned int alienware_m17x_pin_configs[13] = { 1541 0x0321101f, 0x0321101f, 0x03a11020, 0x03014020, 1542 0x90170110, 0x4f0000f0, 0x4f0000f0, 0x4f0000f0, 1543 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0, 1544 0x904601b0, 1545 }; 1546 1547 static const unsigned int intel_dg45id_pin_configs[13] = { 1548 0x02214230, 0x02A19240, 0x01013214, 0x01014210, 1549 0x01A19250, 0x01011212, 0x01016211 1550 }; 1551 1552 static const unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = { 1553 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs, 1554 [STAC_DELL_M6_AMIC] = dell_m6_pin_configs, 1555 [STAC_DELL_M6_DMIC] = dell_m6_pin_configs, 1556 [STAC_DELL_M6_BOTH] = dell_m6_pin_configs, 1557 [STAC_DELL_EQ] = dell_m6_pin_configs, 1558 [STAC_ALIENWARE_M17X] = alienware_m17x_pin_configs, 1559 [STAC_92HD73XX_INTEL] = intel_dg45id_pin_configs, 1560 }; 1561 1562 static const char * const stac92hd73xx_models[STAC_92HD73XX_MODELS] = { 1563 [STAC_92HD73XX_AUTO] = "auto", 1564 [STAC_92HD73XX_NO_JD] = "no-jd", 1565 [STAC_92HD73XX_REF] = "ref", 1566 [STAC_92HD73XX_INTEL] = "intel", 1567 [STAC_DELL_M6_AMIC] = "dell-m6-amic", 1568 [STAC_DELL_M6_DMIC] = "dell-m6-dmic", 1569 [STAC_DELL_M6_BOTH] = "dell-m6", 1570 [STAC_DELL_EQ] = "dell-eq", 1571 [STAC_ALIENWARE_M17X] = "alienware", 1572 }; 1573 1574 static const struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = { 1575 /* SigmaTel reference board */ 1576 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1577 "DFI LanParty", STAC_92HD73XX_REF), 1578 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 1579 "DFI LanParty", STAC_92HD73XX_REF), 1580 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5002, 1581 "Intel DG45ID", STAC_92HD73XX_INTEL), 1582 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5003, 1583 "Intel DG45FC", STAC_92HD73XX_INTEL), 1584 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254, 1585 "Dell Studio 1535", STAC_DELL_M6_DMIC), 1586 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255, 1587 "unknown Dell", STAC_DELL_M6_DMIC), 1588 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256, 1589 "unknown Dell", STAC_DELL_M6_BOTH), 1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257, 1591 "unknown Dell", STAC_DELL_M6_BOTH), 1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e, 1593 "unknown Dell", STAC_DELL_M6_AMIC), 1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f, 1595 "unknown Dell", STAC_DELL_M6_AMIC), 1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271, 1597 "unknown Dell", STAC_DELL_M6_DMIC), 1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0272, 1599 "unknown Dell", STAC_DELL_M6_DMIC), 1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x029f, 1601 "Dell Studio 1537", STAC_DELL_M6_DMIC), 1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a0, 1603 "Dell Studio 17", STAC_DELL_M6_DMIC), 1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02be, 1605 "Dell Studio 1555", STAC_DELL_M6_DMIC), 1606 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02bd, 1607 "Dell Studio 1557", STAC_DELL_M6_DMIC), 1608 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02fe, 1609 "Dell Studio XPS 1645", STAC_DELL_M6_DMIC), 1610 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0413, 1611 "Dell Studio 1558", STAC_DELL_M6_DMIC), 1612 {} /* terminator */ 1613 }; 1614 1615 static const struct snd_pci_quirk stac92hd73xx_codec_id_cfg_tbl[] = { 1616 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02a1, 1617 "Alienware M17x", STAC_ALIENWARE_M17X), 1618 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x043a, 1619 "Alienware M17x", STAC_ALIENWARE_M17X), 1620 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0490, 1621 "Alienware M17x R3", STAC_DELL_EQ), 1622 {} /* terminator */ 1623 }; 1624 1625 static const unsigned int ref92hd83xxx_pin_configs[10] = { 1626 0x02214030, 0x02211010, 0x02a19020, 0x02170130, 1627 0x01014050, 0x01819040, 0x01014020, 0x90a3014e, 1628 0x01451160, 0x98560170, 1629 }; 1630 1631 static const unsigned int dell_s14_pin_configs[10] = { 1632 0x0221403f, 0x0221101f, 0x02a19020, 0x90170110, 1633 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a60160, 1634 0x40f000f0, 0x40f000f0, 1635 }; 1636 1637 static const unsigned int dell_vostro_3500_pin_configs[10] = { 1638 0x02a11020, 0x0221101f, 0x400000f0, 0x90170110, 1639 0x400000f1, 0x400000f2, 0x400000f3, 0x90a60160, 1640 0x400000f4, 0x400000f5, 1641 }; 1642 1643 static const unsigned int hp_dv7_4000_pin_configs[10] = { 1644 0x03a12050, 0x0321201f, 0x40f000f0, 0x90170110, 1645 0x40f000f0, 0x40f000f0, 0x90170110, 0xd5a30140, 1646 0x40f000f0, 0x40f000f0, 1647 }; 1648 1649 static const unsigned int hp_zephyr_pin_configs[10] = { 1650 0x01813050, 0x0421201f, 0x04a1205e, 0x96130310, 1651 0x96130310, 0x0101401f, 0x1111611f, 0xd5a30130, 1652 0, 0, 1653 }; 1654 1655 static const unsigned int hp_cNB11_intquad_pin_configs[10] = { 1656 0x40f000f0, 0x0221101f, 0x02a11020, 0x92170110, 1657 0x40f000f0, 0x92170110, 0x40f000f0, 0xd5a30130, 1658 0x40f000f0, 0x40f000f0, 1659 }; 1660 1661 static const unsigned int *stac92hd83xxx_brd_tbl[STAC_92HD83XXX_MODELS] = { 1662 [STAC_92HD83XXX_REF] = ref92hd83xxx_pin_configs, 1663 [STAC_92HD83XXX_PWR_REF] = ref92hd83xxx_pin_configs, 1664 [STAC_DELL_S14] = dell_s14_pin_configs, 1665 [STAC_DELL_VOSTRO_3500] = dell_vostro_3500_pin_configs, 1666 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = hp_cNB11_intquad_pin_configs, 1667 [STAC_HP_DV7_4000] = hp_dv7_4000_pin_configs, 1668 [STAC_HP_ZEPHYR] = hp_zephyr_pin_configs, 1669 }; 1670 1671 static const char * const stac92hd83xxx_models[STAC_92HD83XXX_MODELS] = { 1672 [STAC_92HD83XXX_AUTO] = "auto", 1673 [STAC_92HD83XXX_REF] = "ref", 1674 [STAC_92HD83XXX_PWR_REF] = "mic-ref", 1675 [STAC_DELL_S14] = "dell-s14", 1676 [STAC_DELL_VOSTRO_3500] = "dell-vostro-3500", 1677 [STAC_92HD83XXX_HP_cNB11_INTQUAD] = "hp_cNB11_intquad", 1678 [STAC_HP_DV7_4000] = "hp-dv7-4000", 1679 [STAC_HP_ZEPHYR] = "hp-zephyr", 1680 [STAC_92HD83XXX_HP_LED] = "hp-led", 1681 [STAC_92HD83XXX_HP_INV_LED] = "hp-inv-led", 1682 }; 1683 1684 static const struct snd_pci_quirk stac92hd83xxx_cfg_tbl[] = { 1685 /* SigmaTel reference board */ 1686 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1687 "DFI LanParty", STAC_92HD83XXX_REF), 1688 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 1689 "DFI LanParty", STAC_92HD83XXX_REF), 1690 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ba, 1691 "unknown Dell", STAC_DELL_S14), 1692 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x1028, 1693 "Dell Vostro 3500", STAC_DELL_VOSTRO_3500), 1694 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1656, 1695 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1696 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1657, 1697 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1698 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1658, 1699 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1700 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x1659, 1701 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1702 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165A, 1703 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1704 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x165B, 1705 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1706 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3388, 1707 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1708 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3389, 1709 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1710 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355B, 1711 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1712 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355C, 1713 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1714 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355D, 1715 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1716 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355E, 1717 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1718 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x355F, 1719 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1720 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3560, 1721 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1722 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358B, 1723 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1724 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358C, 1725 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1726 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x358D, 1727 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1728 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3591, 1729 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1730 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3592, 1731 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1732 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3593, 1733 "HP", STAC_92HD83XXX_HP_cNB11_INTQUAD), 1734 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561, 1735 "HP", STAC_HP_ZEPHYR), 1736 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3660, 1737 "HP Mini", STAC_92HD83XXX_HP_LED), 1738 {} /* terminator */ 1739 }; 1740 1741 static const struct snd_pci_quirk stac92hd83xxx_codec_id_cfg_tbl[] = { 1742 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561, 1743 "HP", STAC_HP_ZEPHYR), 1744 {} /* terminator */ 1745 }; 1746 1747 static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1748 0x02214030, 0x02a19040, 0x01a19020, 0x01014010, 1749 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0, 1750 0x90a000f0, 0x01452050, 0x01452050, 0x00000000, 1751 0x00000000 1752 }; 1753 1754 static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1755 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110, 1756 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0, 1757 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000, 1758 0x00000000 1759 }; 1760 1761 static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1762 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 1763 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0, 1764 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000, 1765 0x00000000 1766 }; 1767 1768 static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1769 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 1770 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0, 1771 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000, 1772 0x00000000 1773 }; 1774 1775 static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = { 1776 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs, 1777 [STAC_DELL_M4_1] = dell_m4_1_pin_configs, 1778 [STAC_DELL_M4_2] = dell_m4_2_pin_configs, 1779 [STAC_DELL_M4_3] = dell_m4_3_pin_configs, 1780 [STAC_HP_M4] = NULL, 1781 [STAC_HP_DV4] = NULL, 1782 [STAC_HP_DV5] = NULL, 1783 [STAC_HP_HDX] = NULL, 1784 [STAC_HP_DV4_1222NR] = NULL, 1785 }; 1786 1787 static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = { 1788 [STAC_92HD71BXX_AUTO] = "auto", 1789 [STAC_92HD71BXX_REF] = "ref", 1790 [STAC_DELL_M4_1] = "dell-m4-1", 1791 [STAC_DELL_M4_2] = "dell-m4-2", 1792 [STAC_DELL_M4_3] = "dell-m4-3", 1793 [STAC_HP_M4] = "hp-m4", 1794 [STAC_HP_DV4] = "hp-dv4", 1795 [STAC_HP_DV5] = "hp-dv5", 1796 [STAC_HP_HDX] = "hp-hdx", 1797 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr", 1798 }; 1799 1800 static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = { 1801 /* SigmaTel reference board */ 1802 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1803 "DFI LanParty", STAC_92HD71BXX_REF), 1804 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 1805 "DFI LanParty", STAC_92HD71BXX_REF), 1806 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb, 1807 "HP dv4-1222nr", STAC_HP_DV4_1222NR), 1808 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720, 1809 "HP", STAC_HP_DV5), 1810 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080, 1811 "HP", STAC_HP_DV5), 1812 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0, 1813 "HP dv4-7", STAC_HP_DV4), 1814 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600, 1815 "HP dv4-7", STAC_HP_DV5), 1816 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610, 1817 "HP HDX", STAC_HP_HDX), /* HDX18 */ 1818 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a, 1819 "HP mini 1000", STAC_HP_M4), 1820 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b, 1821 "HP HDX", STAC_HP_HDX), /* HDX16 */ 1822 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620, 1823 "HP dv6", STAC_HP_DV5), 1824 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061, 1825 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */ 1826 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e, 1827 "HP DV6", STAC_HP_DV5), 1828 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010, 1829 "HP", STAC_HP_DV5), 1830 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233, 1831 "unknown Dell", STAC_DELL_M4_1), 1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234, 1833 "unknown Dell", STAC_DELL_M4_1), 1834 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250, 1835 "unknown Dell", STAC_DELL_M4_1), 1836 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f, 1837 "unknown Dell", STAC_DELL_M4_1), 1838 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d, 1839 "unknown Dell", STAC_DELL_M4_1), 1840 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251, 1841 "unknown Dell", STAC_DELL_M4_1), 1842 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277, 1843 "unknown Dell", STAC_DELL_M4_1), 1844 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263, 1845 "unknown Dell", STAC_DELL_M4_2), 1846 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265, 1847 "unknown Dell", STAC_DELL_M4_2), 1848 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262, 1849 "unknown Dell", STAC_DELL_M4_2), 1850 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264, 1851 "unknown Dell", STAC_DELL_M4_2), 1852 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa, 1853 "unknown Dell", STAC_DELL_M4_3), 1854 {} /* terminator */ 1855 }; 1856 1857 static const unsigned int ref922x_pin_configs[10] = { 1858 0x01014010, 0x01016011, 0x01012012, 0x0221401f, 1859 0x01813122, 0x01011014, 0x01441030, 0x01c41030, 1860 0x40000100, 0x40000100, 1861 }; 1862 1863 /* 1864 STAC 922X pin configs for 1865 102801A7 1866 102801AB 1867 102801A9 1868 102801D1 1869 102801D2 1870 */ 1871 static const unsigned int dell_922x_d81_pin_configs[10] = { 1872 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1873 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1, 1874 0x01813122, 0x400001f2, 1875 }; 1876 1877 /* 1878 STAC 922X pin configs for 1879 102801AC 1880 102801D0 1881 */ 1882 static const unsigned int dell_922x_d82_pin_configs[10] = { 1883 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1884 0x02a19020, 0x01117011, 0x01451140, 0x400001f0, 1885 0x01813122, 0x400001f1, 1886 }; 1887 1888 /* 1889 STAC 922X pin configs for 1890 102801BF 1891 */ 1892 static const unsigned int dell_922x_m81_pin_configs[10] = { 1893 0x0321101f, 0x01112024, 0x01111222, 0x91174220, 1894 0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 1895 0x40C003f1, 0x405003f0, 1896 }; 1897 1898 /* 1899 STAC 9221 A1 pin configs for 1900 102801D7 (Dell XPS M1210) 1901 */ 1902 static const unsigned int dell_922x_m82_pin_configs[10] = { 1903 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 1904 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 1905 0x508003f3, 0x405003f4, 1906 }; 1907 1908 static const unsigned int d945gtp3_pin_configs[10] = { 1909 0x0221401f, 0x01a19022, 0x01813021, 0x01014010, 1910 0x40000100, 0x40000100, 0x40000100, 0x40000100, 1911 0x02a19120, 0x40000100, 1912 }; 1913 1914 static const unsigned int d945gtp5_pin_configs[10] = { 1915 0x0221401f, 0x01011012, 0x01813024, 0x01014010, 1916 0x01a19021, 0x01016011, 0x01452130, 0x40000100, 1917 0x02a19320, 0x40000100, 1918 }; 1919 1920 static const unsigned int intel_mac_v1_pin_configs[10] = { 1921 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd, 1922 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240, 1923 0x400000fc, 0x400000fb, 1924 }; 1925 1926 static const unsigned int intel_mac_v2_pin_configs[10] = { 1927 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1928 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa, 1929 0x400000fc, 0x400000fb, 1930 }; 1931 1932 static const unsigned int intel_mac_v3_pin_configs[10] = { 1933 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1934 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240, 1935 0x400000fc, 0x400000fb, 1936 }; 1937 1938 static const unsigned int intel_mac_v4_pin_configs[10] = { 1939 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1940 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1941 0x400000fc, 0x400000fb, 1942 }; 1943 1944 static const unsigned int intel_mac_v5_pin_configs[10] = { 1945 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1946 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1947 0x400000fc, 0x400000fb, 1948 }; 1949 1950 static const unsigned int ecs202_pin_configs[10] = { 1951 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010, 1952 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1, 1953 0x9037012e, 0x40e000f2, 1954 }; 1955 1956 static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = { 1957 [STAC_D945_REF] = ref922x_pin_configs, 1958 [STAC_D945GTP3] = d945gtp3_pin_configs, 1959 [STAC_D945GTP5] = d945gtp5_pin_configs, 1960 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs, 1961 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs, 1962 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs, 1963 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs, 1964 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs, 1965 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs, 1966 /* for backward compatibility */ 1967 [STAC_MACMINI] = intel_mac_v3_pin_configs, 1968 [STAC_MACBOOK] = intel_mac_v5_pin_configs, 1969 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs, 1970 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs, 1971 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs, 1972 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs, 1973 [STAC_ECS_202] = ecs202_pin_configs, 1974 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs, 1975 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs, 1976 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs, 1977 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs, 1978 }; 1979 1980 static const char * const stac922x_models[STAC_922X_MODELS] = { 1981 [STAC_922X_AUTO] = "auto", 1982 [STAC_D945_REF] = "ref", 1983 [STAC_D945GTP5] = "5stack", 1984 [STAC_D945GTP3] = "3stack", 1985 [STAC_INTEL_MAC_V1] = "intel-mac-v1", 1986 [STAC_INTEL_MAC_V2] = "intel-mac-v2", 1987 [STAC_INTEL_MAC_V3] = "intel-mac-v3", 1988 [STAC_INTEL_MAC_V4] = "intel-mac-v4", 1989 [STAC_INTEL_MAC_V5] = "intel-mac-v5", 1990 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto", 1991 /* for backward compatibility */ 1992 [STAC_MACMINI] = "macmini", 1993 [STAC_MACBOOK] = "macbook", 1994 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1", 1995 [STAC_MACBOOK_PRO_V2] = "macbook-pro", 1996 [STAC_IMAC_INTEL] = "imac-intel", 1997 [STAC_IMAC_INTEL_20] = "imac-intel-20", 1998 [STAC_ECS_202] = "ecs202", 1999 [STAC_922X_DELL_D81] = "dell-d81", 2000 [STAC_922X_DELL_D82] = "dell-d82", 2001 [STAC_922X_DELL_M81] = "dell-m81", 2002 [STAC_922X_DELL_M82] = "dell-m82", 2003 }; 2004 2005 static const struct snd_pci_quirk stac922x_cfg_tbl[] = { 2006 /* SigmaTel reference board */ 2007 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2008 "DFI LanParty", STAC_D945_REF), 2009 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2010 "DFI LanParty", STAC_D945_REF), 2011 /* Intel 945G based systems */ 2012 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101, 2013 "Intel D945G", STAC_D945GTP3), 2014 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202, 2015 "Intel D945G", STAC_D945GTP3), 2016 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606, 2017 "Intel D945G", STAC_D945GTP3), 2018 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601, 2019 "Intel D945G", STAC_D945GTP3), 2020 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111, 2021 "Intel D945G", STAC_D945GTP3), 2022 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115, 2023 "Intel D945G", STAC_D945GTP3), 2024 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116, 2025 "Intel D945G", STAC_D945GTP3), 2026 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117, 2027 "Intel D945G", STAC_D945GTP3), 2028 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118, 2029 "Intel D945G", STAC_D945GTP3), 2030 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119, 2031 "Intel D945G", STAC_D945GTP3), 2032 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826, 2033 "Intel D945G", STAC_D945GTP3), 2034 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049, 2035 "Intel D945G", STAC_D945GTP3), 2036 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055, 2037 "Intel D945G", STAC_D945GTP3), 2038 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048, 2039 "Intel D945G", STAC_D945GTP3), 2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110, 2041 "Intel D945G", STAC_D945GTP3), 2042 /* Intel D945G 5-stack systems */ 2043 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404, 2044 "Intel D945G", STAC_D945GTP5), 2045 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303, 2046 "Intel D945G", STAC_D945GTP5), 2047 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013, 2048 "Intel D945G", STAC_D945GTP5), 2049 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417, 2050 "Intel D945G", STAC_D945GTP5), 2051 /* Intel 945P based systems */ 2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b, 2053 "Intel D945P", STAC_D945GTP3), 2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112, 2055 "Intel D945P", STAC_D945GTP3), 2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d, 2057 "Intel D945P", STAC_D945GTP3), 2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909, 2059 "Intel D945P", STAC_D945GTP3), 2060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505, 2061 "Intel D945P", STAC_D945GTP3), 2062 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707, 2063 "Intel D945P", STAC_D945GTP5), 2064 /* other intel */ 2065 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204, 2066 "Intel D945", STAC_D945_REF), 2067 /* other systems */ 2068 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */ 2069 SND_PCI_QUIRK(0x8384, 0x7680, 2070 "Mac", STAC_INTEL_MAC_AUTO), 2071 /* Dell systems */ 2072 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7, 2073 "unknown Dell", STAC_922X_DELL_D81), 2074 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9, 2075 "unknown Dell", STAC_922X_DELL_D81), 2076 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab, 2077 "unknown Dell", STAC_922X_DELL_D81), 2078 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac, 2079 "unknown Dell", STAC_922X_DELL_D82), 2080 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf, 2081 "unknown Dell", STAC_922X_DELL_M81), 2082 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0, 2083 "unknown Dell", STAC_922X_DELL_D82), 2084 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1, 2085 "unknown Dell", STAC_922X_DELL_D81), 2086 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2, 2087 "unknown Dell", STAC_922X_DELL_D81), 2088 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7, 2089 "Dell XPS M1210", STAC_922X_DELL_M82), 2090 /* ECS/PC Chips boards */ 2091 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000, 2092 "ECS/PC chips", STAC_ECS_202), 2093 {} /* terminator */ 2094 }; 2095 2096 static const unsigned int ref927x_pin_configs[14] = { 2097 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 2098 0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 2099 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070, 2100 0x01c42190, 0x40000100, 2101 }; 2102 2103 static const unsigned int d965_3st_pin_configs[14] = { 2104 0x0221401f, 0x02a19120, 0x40000100, 0x01014011, 2105 0x01a19021, 0x01813024, 0x40000100, 0x40000100, 2106 0x40000100, 0x40000100, 0x40000100, 0x40000100, 2107 0x40000100, 0x40000100 2108 }; 2109 2110 static const unsigned int d965_5st_pin_configs[14] = { 2111 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 2112 0x01a19040, 0x01011012, 0x01016011, 0x40000100, 2113 0x40000100, 0x40000100, 0x40000100, 0x01442070, 2114 0x40000100, 0x40000100 2115 }; 2116 2117 static const unsigned int d965_5st_no_fp_pin_configs[14] = { 2118 0x40000100, 0x40000100, 0x0181304e, 0x01014010, 2119 0x01a19040, 0x01011012, 0x01016011, 0x40000100, 2120 0x40000100, 0x40000100, 0x40000100, 0x01442070, 2121 0x40000100, 0x40000100 2122 }; 2123 2124 static const unsigned int dell_3st_pin_configs[14] = { 2125 0x02211230, 0x02a11220, 0x01a19040, 0x01114210, 2126 0x01111212, 0x01116211, 0x01813050, 0x01112214, 2127 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb, 2128 0x40c003fc, 0x40000100 2129 }; 2130 2131 static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = { 2132 [STAC_D965_REF_NO_JD] = ref927x_pin_configs, 2133 [STAC_D965_REF] = ref927x_pin_configs, 2134 [STAC_D965_3ST] = d965_3st_pin_configs, 2135 [STAC_D965_5ST] = d965_5st_pin_configs, 2136 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs, 2137 [STAC_DELL_3ST] = dell_3st_pin_configs, 2138 [STAC_DELL_BIOS] = NULL, 2139 [STAC_927X_VOLKNOB] = NULL, 2140 }; 2141 2142 static const char * const stac927x_models[STAC_927X_MODELS] = { 2143 [STAC_927X_AUTO] = "auto", 2144 [STAC_D965_REF_NO_JD] = "ref-no-jd", 2145 [STAC_D965_REF] = "ref", 2146 [STAC_D965_3ST] = "3stack", 2147 [STAC_D965_5ST] = "5stack", 2148 [STAC_D965_5ST_NO_FP] = "5stack-no-fp", 2149 [STAC_DELL_3ST] = "dell-3stack", 2150 [STAC_DELL_BIOS] = "dell-bios", 2151 [STAC_927X_VOLKNOB] = "volknob", 2152 }; 2153 2154 static const struct snd_pci_quirk stac927x_cfg_tbl[] = { 2155 /* SigmaTel reference board */ 2156 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2157 "DFI LanParty", STAC_D965_REF), 2158 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2159 "DFI LanParty", STAC_D965_REF), 2160 /* Intel 946 based systems */ 2161 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST), 2162 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST), 2163 /* 965 based 3 stack systems */ 2164 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100, 2165 "Intel D965", STAC_D965_3ST), 2166 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000, 2167 "Intel D965", STAC_D965_3ST), 2168 /* Dell 3 stack systems */ 2169 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST), 2170 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST), 2171 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST), 2172 /* Dell 3 stack systems with verb table in BIOS */ 2173 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS), 2174 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS), 2175 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS), 2176 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS), 2177 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS), 2178 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS), 2179 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS), 2180 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS), 2181 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS), 2182 /* 965 based 5 stack systems */ 2183 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300, 2184 "Intel D965", STAC_D965_5ST), 2185 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500, 2186 "Intel D965", STAC_D965_5ST), 2187 /* volume-knob fixes */ 2188 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB), 2189 {} /* terminator */ 2190 }; 2191 2192 static const unsigned int ref9205_pin_configs[12] = { 2193 0x40000100, 0x40000100, 0x01016011, 0x01014010, 2194 0x01813122, 0x01a19021, 0x01019020, 0x40000100, 2195 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030 2196 }; 2197 2198 /* 2199 STAC 9205 pin configs for 2200 102801F1 2201 102801F2 2202 102801FC 2203 102801FD 2204 10280204 2205 1028021F 2206 10280228 (Dell Vostro 1500) 2207 10280229 (Dell Vostro 1700) 2208 */ 2209 static const unsigned int dell_9205_m42_pin_configs[12] = { 2210 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310, 2211 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9, 2212 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE, 2213 }; 2214 2215 /* 2216 STAC 9205 pin configs for 2217 102801F9 2218 102801FA 2219 102801FE 2220 102801FF (Dell Precision M4300) 2221 10280206 2222 10280200 2223 10280201 2224 */ 2225 static const unsigned int dell_9205_m43_pin_configs[12] = { 2226 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310, 2227 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9, 2228 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8, 2229 }; 2230 2231 static const unsigned int dell_9205_m44_pin_configs[12] = { 2232 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310, 2233 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9, 2234 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe, 2235 }; 2236 2237 static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = { 2238 [STAC_9205_REF] = ref9205_pin_configs, 2239 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs, 2240 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs, 2241 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs, 2242 [STAC_9205_EAPD] = NULL, 2243 }; 2244 2245 static const char * const stac9205_models[STAC_9205_MODELS] = { 2246 [STAC_9205_AUTO] = "auto", 2247 [STAC_9205_REF] = "ref", 2248 [STAC_9205_DELL_M42] = "dell-m42", 2249 [STAC_9205_DELL_M43] = "dell-m43", 2250 [STAC_9205_DELL_M44] = "dell-m44", 2251 [STAC_9205_EAPD] = "eapd", 2252 }; 2253 2254 static const struct snd_pci_quirk stac9205_cfg_tbl[] = { 2255 /* SigmaTel reference board */ 2256 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2257 "DFI LanParty", STAC_9205_REF), 2258 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30, 2259 "SigmaTel", STAC_9205_REF), 2260 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2261 "DFI LanParty", STAC_9205_REF), 2262 /* Dell */ 2263 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1, 2264 "unknown Dell", STAC_9205_DELL_M42), 2265 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2, 2266 "unknown Dell", STAC_9205_DELL_M42), 2267 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8, 2268 "Dell Precision", STAC_9205_DELL_M43), 2269 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9, 2270 "Dell Precision", STAC_9205_DELL_M43), 2271 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa, 2272 "Dell Precision", STAC_9205_DELL_M43), 2273 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc, 2274 "unknown Dell", STAC_9205_DELL_M42), 2275 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd, 2276 "unknown Dell", STAC_9205_DELL_M42), 2277 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe, 2278 "Dell Precision", STAC_9205_DELL_M43), 2279 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff, 2280 "Dell Precision M4300", STAC_9205_DELL_M43), 2281 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204, 2282 "unknown Dell", STAC_9205_DELL_M42), 2283 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206, 2284 "Dell Precision", STAC_9205_DELL_M43), 2285 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b, 2286 "Dell Precision", STAC_9205_DELL_M43), 2287 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c, 2288 "Dell Precision", STAC_9205_DELL_M43), 2289 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f, 2290 "Dell Inspiron", STAC_9205_DELL_M44), 2291 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228, 2292 "Dell Vostro 1500", STAC_9205_DELL_M42), 2293 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229, 2294 "Dell Vostro 1700", STAC_9205_DELL_M42), 2295 /* Gateway */ 2296 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD), 2297 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD), 2298 {} /* terminator */ 2299 }; 2300 2301 static void stac92xx_set_config_regs(struct hda_codec *codec, 2302 const unsigned int *pincfgs) 2303 { 2304 int i; 2305 struct sigmatel_spec *spec = codec->spec; 2306 2307 if (!pincfgs) 2308 return; 2309 2310 for (i = 0; i < spec->num_pins; i++) 2311 if (spec->pin_nids[i] && pincfgs[i]) 2312 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i], 2313 pincfgs[i]); 2314 } 2315 2316 /* 2317 * Analog playback callbacks 2318 */ 2319 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo, 2320 struct hda_codec *codec, 2321 struct snd_pcm_substream *substream) 2322 { 2323 struct sigmatel_spec *spec = codec->spec; 2324 if (spec->stream_delay) 2325 msleep(spec->stream_delay); 2326 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2327 hinfo); 2328 } 2329 2330 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2331 struct hda_codec *codec, 2332 unsigned int stream_tag, 2333 unsigned int format, 2334 struct snd_pcm_substream *substream) 2335 { 2336 struct sigmatel_spec *spec = codec->spec; 2337 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream); 2338 } 2339 2340 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2341 struct hda_codec *codec, 2342 struct snd_pcm_substream *substream) 2343 { 2344 struct sigmatel_spec *spec = codec->spec; 2345 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2346 } 2347 2348 /* 2349 * Digital playback callbacks 2350 */ 2351 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2352 struct hda_codec *codec, 2353 struct snd_pcm_substream *substream) 2354 { 2355 struct sigmatel_spec *spec = codec->spec; 2356 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2357 } 2358 2359 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2360 struct hda_codec *codec, 2361 struct snd_pcm_substream *substream) 2362 { 2363 struct sigmatel_spec *spec = codec->spec; 2364 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2365 } 2366 2367 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2368 struct hda_codec *codec, 2369 unsigned int stream_tag, 2370 unsigned int format, 2371 struct snd_pcm_substream *substream) 2372 { 2373 struct sigmatel_spec *spec = codec->spec; 2374 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2375 stream_tag, format, substream); 2376 } 2377 2378 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2379 struct hda_codec *codec, 2380 struct snd_pcm_substream *substream) 2381 { 2382 struct sigmatel_spec *spec = codec->spec; 2383 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 2384 } 2385 2386 2387 /* 2388 * Analog capture callbacks 2389 */ 2390 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2391 struct hda_codec *codec, 2392 unsigned int stream_tag, 2393 unsigned int format, 2394 struct snd_pcm_substream *substream) 2395 { 2396 struct sigmatel_spec *spec = codec->spec; 2397 hda_nid_t nid = spec->adc_nids[substream->number]; 2398 2399 if (spec->powerdown_adcs) { 2400 msleep(40); 2401 snd_hda_codec_write(codec, nid, 0, 2402 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 2403 } 2404 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 2405 return 0; 2406 } 2407 2408 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2409 struct hda_codec *codec, 2410 struct snd_pcm_substream *substream) 2411 { 2412 struct sigmatel_spec *spec = codec->spec; 2413 hda_nid_t nid = spec->adc_nids[substream->number]; 2414 2415 snd_hda_codec_cleanup_stream(codec, nid); 2416 if (spec->powerdown_adcs) 2417 snd_hda_codec_write(codec, nid, 0, 2418 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 2419 return 0; 2420 } 2421 2422 static const struct hda_pcm_stream stac92xx_pcm_digital_playback = { 2423 .substreams = 1, 2424 .channels_min = 2, 2425 .channels_max = 2, 2426 /* NID is set in stac92xx_build_pcms */ 2427 .ops = { 2428 .open = stac92xx_dig_playback_pcm_open, 2429 .close = stac92xx_dig_playback_pcm_close, 2430 .prepare = stac92xx_dig_playback_pcm_prepare, 2431 .cleanup = stac92xx_dig_playback_pcm_cleanup 2432 }, 2433 }; 2434 2435 static const struct hda_pcm_stream stac92xx_pcm_digital_capture = { 2436 .substreams = 1, 2437 .channels_min = 2, 2438 .channels_max = 2, 2439 /* NID is set in stac92xx_build_pcms */ 2440 }; 2441 2442 static const struct hda_pcm_stream stac92xx_pcm_analog_playback = { 2443 .substreams = 1, 2444 .channels_min = 2, 2445 .channels_max = 8, 2446 .nid = 0x02, /* NID to query formats and rates */ 2447 .ops = { 2448 .open = stac92xx_playback_pcm_open, 2449 .prepare = stac92xx_playback_pcm_prepare, 2450 .cleanup = stac92xx_playback_pcm_cleanup 2451 }, 2452 }; 2453 2454 static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = { 2455 .substreams = 1, 2456 .channels_min = 2, 2457 .channels_max = 2, 2458 .nid = 0x06, /* NID to query formats and rates */ 2459 .ops = { 2460 .open = stac92xx_playback_pcm_open, 2461 .prepare = stac92xx_playback_pcm_prepare, 2462 .cleanup = stac92xx_playback_pcm_cleanup 2463 }, 2464 }; 2465 2466 static const struct hda_pcm_stream stac92xx_pcm_analog_capture = { 2467 .channels_min = 2, 2468 .channels_max = 2, 2469 /* NID + .substreams is set in stac92xx_build_pcms */ 2470 .ops = { 2471 .prepare = stac92xx_capture_pcm_prepare, 2472 .cleanup = stac92xx_capture_pcm_cleanup 2473 }, 2474 }; 2475 2476 static int stac92xx_build_pcms(struct hda_codec *codec) 2477 { 2478 struct sigmatel_spec *spec = codec->spec; 2479 struct hda_pcm *info = spec->pcm_rec; 2480 2481 codec->num_pcms = 1; 2482 codec->pcm_info = info; 2483 2484 info->name = "STAC92xx Analog"; 2485 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback; 2486 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2487 spec->multiout.dac_nids[0]; 2488 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture; 2489 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2490 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs; 2491 2492 if (spec->alt_switch) { 2493 codec->num_pcms++; 2494 info++; 2495 info->name = "STAC92xx Analog Alt"; 2496 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback; 2497 } 2498 2499 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2500 codec->num_pcms++; 2501 info++; 2502 info->name = "STAC92xx Digital"; 2503 info->pcm_type = spec->autocfg.dig_out_type[0]; 2504 if (spec->multiout.dig_out_nid) { 2505 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback; 2506 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2507 } 2508 if (spec->dig_in_nid) { 2509 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture; 2510 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2511 } 2512 } 2513 2514 return 0; 2515 } 2516 2517 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) 2518 2519 { 2520 snd_hda_set_pin_ctl_cache(codec, nid, pin_type); 2521 } 2522 2523 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info 2524 2525 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol, 2526 struct snd_ctl_elem_value *ucontrol) 2527 { 2528 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2529 struct sigmatel_spec *spec = codec->spec; 2530 2531 ucontrol->value.integer.value[0] = !!spec->hp_switch; 2532 return 0; 2533 } 2534 2535 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid); 2536 2537 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol, 2538 struct snd_ctl_elem_value *ucontrol) 2539 { 2540 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2541 struct sigmatel_spec *spec = codec->spec; 2542 int nid = kcontrol->private_value; 2543 2544 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0; 2545 2546 /* check to be sure that the ports are up to date with 2547 * switch changes 2548 */ 2549 stac_issue_unsol_event(codec, nid); 2550 2551 return 1; 2552 } 2553 2554 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol, 2555 struct snd_ctl_elem_info *uinfo) 2556 { 2557 int i; 2558 static const char * const texts[] = { 2559 "Mic In", "Line In", "Line Out" 2560 }; 2561 2562 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2563 struct sigmatel_spec *spec = codec->spec; 2564 hda_nid_t nid = kcontrol->private_value; 2565 2566 if (nid == spec->mic_switch || nid == spec->line_switch) 2567 i = 3; 2568 else 2569 i = 2; 2570 2571 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2572 uinfo->value.enumerated.items = i; 2573 uinfo->count = 1; 2574 if (uinfo->value.enumerated.item >= i) 2575 uinfo->value.enumerated.item = i-1; 2576 strcpy(uinfo->value.enumerated.name, 2577 texts[uinfo->value.enumerated.item]); 2578 2579 return 0; 2580 } 2581 2582 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol, 2583 struct snd_ctl_elem_value *ucontrol) 2584 { 2585 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2586 hda_nid_t nid = kcontrol->private_value; 2587 unsigned int vref = stac92xx_vref_get(codec, nid); 2588 2589 if (vref == snd_hda_get_default_vref(codec, nid)) 2590 ucontrol->value.enumerated.item[0] = 0; 2591 else if (vref == AC_PINCTL_VREF_GRD) 2592 ucontrol->value.enumerated.item[0] = 1; 2593 else if (vref == AC_PINCTL_VREF_HIZ) 2594 ucontrol->value.enumerated.item[0] = 2; 2595 2596 return 0; 2597 } 2598 2599 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol, 2600 struct snd_ctl_elem_value *ucontrol) 2601 { 2602 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2603 unsigned int new_vref = 0; 2604 int error; 2605 hda_nid_t nid = kcontrol->private_value; 2606 2607 if (ucontrol->value.enumerated.item[0] == 0) 2608 new_vref = snd_hda_get_default_vref(codec, nid); 2609 else if (ucontrol->value.enumerated.item[0] == 1) 2610 new_vref = AC_PINCTL_VREF_GRD; 2611 else if (ucontrol->value.enumerated.item[0] == 2) 2612 new_vref = AC_PINCTL_VREF_HIZ; 2613 else 2614 return 0; 2615 2616 if (new_vref != stac92xx_vref_get(codec, nid)) { 2617 error = stac92xx_vref_set(codec, nid, new_vref); 2618 return error; 2619 } 2620 2621 return 0; 2622 } 2623 2624 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol, 2625 struct snd_ctl_elem_info *uinfo) 2626 { 2627 char *texts[2]; 2628 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2629 struct sigmatel_spec *spec = codec->spec; 2630 2631 if (kcontrol->private_value == spec->line_switch) 2632 texts[0] = "Line In"; 2633 else 2634 texts[0] = "Mic In"; 2635 texts[1] = "Line Out"; 2636 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2637 uinfo->value.enumerated.items = 2; 2638 uinfo->count = 1; 2639 2640 if (uinfo->value.enumerated.item >= 2) 2641 uinfo->value.enumerated.item = 1; 2642 strcpy(uinfo->value.enumerated.name, 2643 texts[uinfo->value.enumerated.item]); 2644 2645 return 0; 2646 } 2647 2648 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2649 { 2650 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2651 struct sigmatel_spec *spec = codec->spec; 2652 hda_nid_t nid = kcontrol->private_value; 2653 int io_idx = (nid == spec->mic_switch) ? 1 : 0; 2654 2655 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx]; 2656 return 0; 2657 } 2658 2659 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2660 { 2661 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2662 struct sigmatel_spec *spec = codec->spec; 2663 hda_nid_t nid = kcontrol->private_value; 2664 int io_idx = (nid == spec->mic_switch) ? 1 : 0; 2665 unsigned short val = !!ucontrol->value.enumerated.item[0]; 2666 2667 spec->io_switch[io_idx] = val; 2668 2669 if (val) 2670 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 2671 else { 2672 unsigned int pinctl = AC_PINCTL_IN_EN; 2673 if (io_idx) /* set VREF for mic */ 2674 pinctl |= snd_hda_get_default_vref(codec, nid); 2675 stac92xx_auto_set_pinctl(codec, nid, pinctl); 2676 } 2677 2678 /* check the auto-mute again: we need to mute/unmute the speaker 2679 * appropriately according to the pin direction 2680 */ 2681 if (spec->hp_detect) 2682 stac_issue_unsol_event(codec, nid); 2683 2684 return 1; 2685 } 2686 2687 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info 2688 2689 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol, 2690 struct snd_ctl_elem_value *ucontrol) 2691 { 2692 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2693 struct sigmatel_spec *spec = codec->spec; 2694 2695 ucontrol->value.integer.value[0] = spec->clfe_swap; 2696 return 0; 2697 } 2698 2699 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol, 2700 struct snd_ctl_elem_value *ucontrol) 2701 { 2702 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2703 struct sigmatel_spec *spec = codec->spec; 2704 hda_nid_t nid = kcontrol->private_value & 0xff; 2705 unsigned int val = !!ucontrol->value.integer.value[0]; 2706 2707 if (spec->clfe_swap == val) 2708 return 0; 2709 2710 spec->clfe_swap = val; 2711 2712 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 2713 spec->clfe_swap ? 0x4 : 0x0); 2714 2715 return 1; 2716 } 2717 2718 #define STAC_CODEC_HP_SWITCH(xname) \ 2719 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2720 .name = xname, \ 2721 .index = 0, \ 2722 .info = stac92xx_hp_switch_info, \ 2723 .get = stac92xx_hp_switch_get, \ 2724 .put = stac92xx_hp_switch_put, \ 2725 } 2726 2727 #define STAC_CODEC_IO_SWITCH(xname, xpval) \ 2728 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2729 .name = xname, \ 2730 .index = 0, \ 2731 .info = stac92xx_io_switch_info, \ 2732 .get = stac92xx_io_switch_get, \ 2733 .put = stac92xx_io_switch_put, \ 2734 .private_value = xpval, \ 2735 } 2736 2737 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \ 2738 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2739 .name = xname, \ 2740 .index = 0, \ 2741 .info = stac92xx_clfe_switch_info, \ 2742 .get = stac92xx_clfe_switch_get, \ 2743 .put = stac92xx_clfe_switch_put, \ 2744 .private_value = xpval, \ 2745 } 2746 2747 enum { 2748 STAC_CTL_WIDGET_VOL, 2749 STAC_CTL_WIDGET_MUTE, 2750 STAC_CTL_WIDGET_MUTE_BEEP, 2751 STAC_CTL_WIDGET_MONO_MUX, 2752 STAC_CTL_WIDGET_HP_SWITCH, 2753 STAC_CTL_WIDGET_IO_SWITCH, 2754 STAC_CTL_WIDGET_CLFE_SWITCH, 2755 STAC_CTL_WIDGET_DC_BIAS 2756 }; 2757 2758 static const struct snd_kcontrol_new stac92xx_control_templates[] = { 2759 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2760 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2761 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0), 2762 STAC_MONO_MUX, 2763 STAC_CODEC_HP_SWITCH(NULL), 2764 STAC_CODEC_IO_SWITCH(NULL, 0), 2765 STAC_CODEC_CLFE_SWITCH(NULL, 0), 2766 DC_BIAS(NULL, 0, 0), 2767 }; 2768 2769 /* add dynamic controls */ 2770 static struct snd_kcontrol_new * 2771 stac_control_new(struct sigmatel_spec *spec, 2772 const struct snd_kcontrol_new *ktemp, 2773 const char *name, 2774 unsigned int subdev) 2775 { 2776 struct snd_kcontrol_new *knew; 2777 2778 snd_array_init(&spec->kctls, sizeof(*knew), 32); 2779 knew = snd_array_new(&spec->kctls); 2780 if (!knew) 2781 return NULL; 2782 *knew = *ktemp; 2783 knew->name = kstrdup(name, GFP_KERNEL); 2784 if (!knew->name) { 2785 /* roolback */ 2786 memset(knew, 0, sizeof(*knew)); 2787 spec->kctls.alloced--; 2788 return NULL; 2789 } 2790 knew->subdevice = subdev; 2791 return knew; 2792 } 2793 2794 static int stac92xx_add_control_temp(struct sigmatel_spec *spec, 2795 const struct snd_kcontrol_new *ktemp, 2796 int idx, const char *name, 2797 unsigned long val) 2798 { 2799 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name, 2800 HDA_SUBDEV_AMP_FLAG); 2801 if (!knew) 2802 return -ENOMEM; 2803 knew->index = idx; 2804 knew->private_value = val; 2805 return 0; 2806 } 2807 2808 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec, 2809 int type, int idx, const char *name, 2810 unsigned long val) 2811 { 2812 return stac92xx_add_control_temp(spec, 2813 &stac92xx_control_templates[type], 2814 idx, name, val); 2815 } 2816 2817 2818 /* add dynamic controls */ 2819 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type, 2820 const char *name, unsigned long val) 2821 { 2822 return stac92xx_add_control_idx(spec, type, 0, name, val); 2823 } 2824 2825 static const struct snd_kcontrol_new stac_input_src_temp = { 2826 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2827 .name = "Input Source", 2828 .info = stac92xx_mux_enum_info, 2829 .get = stac92xx_mux_enum_get, 2830 .put = stac92xx_mux_enum_put, 2831 }; 2832 2833 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec, 2834 hda_nid_t nid, int idx) 2835 { 2836 int def_conf = snd_hda_codec_get_pincfg(codec, nid); 2837 int control = 0; 2838 struct sigmatel_spec *spec = codec->spec; 2839 char name[22]; 2840 2841 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { 2842 if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD 2843 && nid == spec->line_switch) 2844 control = STAC_CTL_WIDGET_IO_SWITCH; 2845 else if (snd_hda_query_pin_caps(codec, nid) 2846 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT)) 2847 control = STAC_CTL_WIDGET_DC_BIAS; 2848 else if (nid == spec->mic_switch) 2849 control = STAC_CTL_WIDGET_IO_SWITCH; 2850 } 2851 2852 if (control) { 2853 snd_hda_get_pin_label(codec, nid, &spec->autocfg, 2854 name, sizeof(name), NULL); 2855 return stac92xx_add_control(codec->spec, control, 2856 strcat(name, " Jack Mode"), nid); 2857 } 2858 2859 return 0; 2860 } 2861 2862 static int stac92xx_add_input_source(struct sigmatel_spec *spec) 2863 { 2864 struct snd_kcontrol_new *knew; 2865 struct hda_input_mux *imux = &spec->private_imux; 2866 2867 if (spec->auto_mic) 2868 return 0; /* no need for input source */ 2869 if (!spec->num_adcs || imux->num_items <= 1) 2870 return 0; /* no need for input source control */ 2871 knew = stac_control_new(spec, &stac_input_src_temp, 2872 stac_input_src_temp.name, 0); 2873 if (!knew) 2874 return -ENOMEM; 2875 knew->count = spec->num_adcs; 2876 return 0; 2877 } 2878 2879 /* check whether the line-input can be used as line-out */ 2880 static hda_nid_t check_line_out_switch(struct hda_codec *codec) 2881 { 2882 struct sigmatel_spec *spec = codec->spec; 2883 struct auto_pin_cfg *cfg = &spec->autocfg; 2884 hda_nid_t nid; 2885 unsigned int pincap; 2886 int i; 2887 2888 if (cfg->line_out_type != AUTO_PIN_LINE_OUT) 2889 return 0; 2890 for (i = 0; i < cfg->num_inputs; i++) { 2891 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) { 2892 nid = cfg->inputs[i].pin; 2893 pincap = snd_hda_query_pin_caps(codec, nid); 2894 if (pincap & AC_PINCAP_OUT) 2895 return nid; 2896 } 2897 } 2898 return 0; 2899 } 2900 2901 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid); 2902 2903 /* check whether the mic-input can be used as line-out */ 2904 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) 2905 { 2906 struct sigmatel_spec *spec = codec->spec; 2907 struct auto_pin_cfg *cfg = &spec->autocfg; 2908 unsigned int def_conf, pincap; 2909 int i; 2910 2911 *dac = 0; 2912 if (cfg->line_out_type != AUTO_PIN_LINE_OUT) 2913 return 0; 2914 for (i = 0; i < cfg->num_inputs; i++) { 2915 hda_nid_t nid = cfg->inputs[i].pin; 2916 if (cfg->inputs[i].type != AUTO_PIN_MIC) 2917 continue; 2918 def_conf = snd_hda_codec_get_pincfg(codec, nid); 2919 /* some laptops have an internal analog microphone 2920 * which can't be used as a output */ 2921 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { 2922 pincap = snd_hda_query_pin_caps(codec, nid); 2923 if (pincap & AC_PINCAP_OUT) { 2924 *dac = get_unassigned_dac(codec, nid); 2925 if (*dac) 2926 return nid; 2927 } 2928 } 2929 } 2930 return 0; 2931 } 2932 2933 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2934 { 2935 int i; 2936 2937 for (i = 0; i < spec->multiout.num_dacs; i++) { 2938 if (spec->multiout.dac_nids[i] == nid) 2939 return 1; 2940 } 2941 2942 return 0; 2943 } 2944 2945 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2946 { 2947 int i; 2948 if (is_in_dac_nids(spec, nid)) 2949 return 1; 2950 for (i = 0; i < spec->autocfg.hp_outs; i++) 2951 if (spec->hp_dacs[i] == nid) 2952 return 1; 2953 for (i = 0; i < spec->autocfg.speaker_outs; i++) 2954 if (spec->speaker_dacs[i] == nid) 2955 return 1; 2956 return 0; 2957 } 2958 2959 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid) 2960 { 2961 struct sigmatel_spec *spec = codec->spec; 2962 struct auto_pin_cfg *cfg = &spec->autocfg; 2963 int j, conn_len; 2964 hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac; 2965 unsigned int wcaps, wtype; 2966 2967 conn_len = snd_hda_get_connections(codec, nid, conn, 2968 HDA_MAX_CONNECTIONS); 2969 /* 92HD88: trace back up the link of nids to find the DAC */ 2970 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0])) 2971 != AC_WID_AUD_OUT)) { 2972 nid = conn[0]; 2973 conn_len = snd_hda_get_connections(codec, nid, conn, 2974 HDA_MAX_CONNECTIONS); 2975 } 2976 for (j = 0; j < conn_len; j++) { 2977 wcaps = get_wcaps(codec, conn[j]); 2978 wtype = get_wcaps_type(wcaps); 2979 /* we check only analog outputs */ 2980 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL)) 2981 continue; 2982 /* if this route has a free DAC, assign it */ 2983 if (!check_all_dac_nids(spec, conn[j])) { 2984 if (conn_len > 1) { 2985 /* select this DAC in the pin's input mux */ 2986 snd_hda_codec_write_cache(codec, nid, 0, 2987 AC_VERB_SET_CONNECT_SEL, j); 2988 } 2989 return conn[j]; 2990 } 2991 } 2992 2993 /* if all DACs are already assigned, connect to the primary DAC, 2994 unless we're assigning a secondary headphone */ 2995 fallback_dac = spec->multiout.dac_nids[0]; 2996 if (spec->multiout.hp_nid) { 2997 for (j = 0; j < cfg->hp_outs; j++) 2998 if (cfg->hp_pins[j] == nid) { 2999 fallback_dac = spec->multiout.hp_nid; 3000 break; 3001 } 3002 } 3003 3004 if (conn_len > 1) { 3005 for (j = 0; j < conn_len; j++) { 3006 if (conn[j] == fallback_dac) { 3007 snd_hda_codec_write_cache(codec, nid, 0, 3008 AC_VERB_SET_CONNECT_SEL, j); 3009 break; 3010 } 3011 } 3012 } 3013 return 0; 3014 } 3015 3016 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid); 3017 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid); 3018 3019 /* 3020 * Fill in the dac_nids table from the parsed pin configuration 3021 * This function only works when every pin in line_out_pins[] 3022 * contains atleast one DAC in its connection list. Some 92xx 3023 * codecs are not connected directly to a DAC, such as the 9200 3024 * and 9202/925x. For those, dac_nids[] must be hard-coded. 3025 */ 3026 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec) 3027 { 3028 struct sigmatel_spec *spec = codec->spec; 3029 struct auto_pin_cfg *cfg = &spec->autocfg; 3030 int i; 3031 hda_nid_t nid, dac; 3032 3033 for (i = 0; i < cfg->line_outs; i++) { 3034 nid = cfg->line_out_pins[i]; 3035 dac = get_unassigned_dac(codec, nid); 3036 if (!dac) { 3037 if (spec->multiout.num_dacs > 0) { 3038 /* we have already working output pins, 3039 * so let's drop the broken ones again 3040 */ 3041 cfg->line_outs = spec->multiout.num_dacs; 3042 break; 3043 } 3044 /* error out, no available DAC found */ 3045 snd_printk(KERN_ERR 3046 "%s: No available DAC for pin 0x%x\n", 3047 __func__, nid); 3048 return -ENODEV; 3049 } 3050 add_spec_dacs(spec, dac); 3051 } 3052 3053 for (i = 0; i < cfg->hp_outs; i++) { 3054 nid = cfg->hp_pins[i]; 3055 dac = get_unassigned_dac(codec, nid); 3056 if (dac) { 3057 if (!spec->multiout.hp_nid) 3058 spec->multiout.hp_nid = dac; 3059 else 3060 add_spec_extra_dacs(spec, dac); 3061 } 3062 spec->hp_dacs[i] = dac; 3063 } 3064 3065 for (i = 0; i < cfg->speaker_outs; i++) { 3066 nid = cfg->speaker_pins[i]; 3067 dac = get_unassigned_dac(codec, nid); 3068 if (dac) 3069 add_spec_extra_dacs(spec, dac); 3070 spec->speaker_dacs[i] = dac; 3071 } 3072 3073 /* add line-in as output */ 3074 nid = check_line_out_switch(codec); 3075 if (nid) { 3076 dac = get_unassigned_dac(codec, nid); 3077 if (dac) { 3078 snd_printdd("STAC: Add line-in 0x%x as output %d\n", 3079 nid, cfg->line_outs); 3080 cfg->line_out_pins[cfg->line_outs] = nid; 3081 cfg->line_outs++; 3082 spec->line_switch = nid; 3083 add_spec_dacs(spec, dac); 3084 } 3085 } 3086 /* add mic as output */ 3087 nid = check_mic_out_switch(codec, &dac); 3088 if (nid && dac) { 3089 snd_printdd("STAC: Add mic-in 0x%x as output %d\n", 3090 nid, cfg->line_outs); 3091 cfg->line_out_pins[cfg->line_outs] = nid; 3092 cfg->line_outs++; 3093 spec->mic_switch = nid; 3094 add_spec_dacs(spec, dac); 3095 } 3096 3097 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3098 spec->multiout.num_dacs, 3099 spec->multiout.dac_nids[0], 3100 spec->multiout.dac_nids[1], 3101 spec->multiout.dac_nids[2], 3102 spec->multiout.dac_nids[3], 3103 spec->multiout.dac_nids[4]); 3104 3105 return 0; 3106 } 3107 3108 /* create volume control/switch for the given prefx type */ 3109 static int create_controls_idx(struct hda_codec *codec, const char *pfx, 3110 int idx, hda_nid_t nid, int chs) 3111 { 3112 struct sigmatel_spec *spec = codec->spec; 3113 char name[32]; 3114 int err; 3115 3116 if (!spec->check_volume_offset) { 3117 unsigned int caps, step, nums, db_scale; 3118 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3119 step = (caps & AC_AMPCAP_STEP_SIZE) >> 3120 AC_AMPCAP_STEP_SIZE_SHIFT; 3121 step = (step + 1) * 25; /* in .01dB unit */ 3122 nums = (caps & AC_AMPCAP_NUM_STEPS) >> 3123 AC_AMPCAP_NUM_STEPS_SHIFT; 3124 db_scale = nums * step; 3125 /* if dB scale is over -64dB, and finer enough, 3126 * let's reduce it to half 3127 */ 3128 if (db_scale > 6400 && nums >= 0x1f) 3129 spec->volume_offset = nums / 2; 3130 spec->check_volume_offset = 1; 3131 } 3132 3133 sprintf(name, "%s Playback Volume", pfx); 3134 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name, 3135 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT, 3136 spec->volume_offset)); 3137 if (err < 0) 3138 return err; 3139 sprintf(name, "%s Playback Switch", pfx); 3140 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name, 3141 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 3142 if (err < 0) 3143 return err; 3144 return 0; 3145 } 3146 3147 #define create_controls(codec, pfx, nid, chs) \ 3148 create_controls_idx(codec, pfx, 0, nid, chs) 3149 3150 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid) 3151 { 3152 if (spec->multiout.num_dacs > 4) { 3153 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid); 3154 return 1; 3155 } else { 3156 snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids); 3157 spec->dac_nids[spec->multiout.num_dacs] = nid; 3158 spec->multiout.num_dacs++; 3159 } 3160 return 0; 3161 } 3162 3163 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid) 3164 { 3165 int i; 3166 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) { 3167 if (!spec->multiout.extra_out_nid[i]) { 3168 spec->multiout.extra_out_nid[i] = nid; 3169 return 0; 3170 } 3171 } 3172 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid); 3173 return 1; 3174 } 3175 3176 /* Create output controls 3177 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT) 3178 */ 3179 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs, 3180 const hda_nid_t *pins, 3181 const hda_nid_t *dac_nids, 3182 int type) 3183 { 3184 struct sigmatel_spec *spec = codec->spec; 3185 static const char * const chname[4] = { 3186 "Front", "Surround", NULL /*CLFE*/, "Side" 3187 }; 3188 hda_nid_t nid; 3189 int i, err; 3190 unsigned int wid_caps; 3191 3192 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) { 3193 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) { 3194 if (is_jack_detectable(codec, pins[i])) 3195 spec->hp_detect = 1; 3196 } 3197 nid = dac_nids[i]; 3198 if (!nid) 3199 continue; 3200 if (type != AUTO_PIN_HP_OUT && i == 2) { 3201 /* Center/LFE */ 3202 err = create_controls(codec, "Center", nid, 1); 3203 if (err < 0) 3204 return err; 3205 err = create_controls(codec, "LFE", nid, 2); 3206 if (err < 0) 3207 return err; 3208 3209 wid_caps = get_wcaps(codec, nid); 3210 3211 if (wid_caps & AC_WCAP_LR_SWAP) { 3212 err = stac92xx_add_control(spec, 3213 STAC_CTL_WIDGET_CLFE_SWITCH, 3214 "Swap Center/LFE Playback Switch", nid); 3215 3216 if (err < 0) 3217 return err; 3218 } 3219 3220 } else { 3221 const char *name; 3222 int idx; 3223 switch (type) { 3224 case AUTO_PIN_HP_OUT: 3225 name = "Headphone"; 3226 idx = i; 3227 break; 3228 case AUTO_PIN_SPEAKER_OUT: 3229 name = "Speaker"; 3230 idx = i; 3231 break; 3232 default: 3233 name = chname[i]; 3234 idx = 0; 3235 break; 3236 } 3237 err = create_controls_idx(codec, name, idx, nid, 3); 3238 if (err < 0) 3239 return err; 3240 } 3241 } 3242 return 0; 3243 } 3244 3245 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol, 3246 unsigned long sw, int idx) 3247 { 3248 int err; 3249 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, 3250 "Capture Volume", vol); 3251 if (err < 0) 3252 return err; 3253 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_MUTE, idx, 3254 "Capture Switch", sw); 3255 if (err < 0) 3256 return err; 3257 return 0; 3258 } 3259 3260 /* add playback controls from the parsed DAC table */ 3261 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec, 3262 const struct auto_pin_cfg *cfg) 3263 { 3264 struct sigmatel_spec *spec = codec->spec; 3265 hda_nid_t nid; 3266 int err; 3267 int idx; 3268 3269 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins, 3270 spec->multiout.dac_nids, 3271 cfg->line_out_type); 3272 if (err < 0) 3273 return err; 3274 3275 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) { 3276 err = stac92xx_add_control(spec, 3277 STAC_CTL_WIDGET_HP_SWITCH, 3278 "Headphone as Line Out Switch", 3279 cfg->hp_pins[cfg->hp_outs - 1]); 3280 if (err < 0) 3281 return err; 3282 } 3283 3284 for (idx = 0; idx < cfg->num_inputs; idx++) { 3285 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN) 3286 break; 3287 nid = cfg->inputs[idx].pin; 3288 err = stac92xx_add_jack_mode_control(codec, nid, idx); 3289 if (err < 0) 3290 return err; 3291 } 3292 3293 return 0; 3294 } 3295 3296 /* add playback controls for Speaker and HP outputs */ 3297 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, 3298 struct auto_pin_cfg *cfg) 3299 { 3300 struct sigmatel_spec *spec = codec->spec; 3301 int err; 3302 3303 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins, 3304 spec->hp_dacs, AUTO_PIN_HP_OUT); 3305 if (err < 0) 3306 return err; 3307 3308 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, 3309 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT); 3310 if (err < 0) 3311 return err; 3312 3313 return 0; 3314 } 3315 3316 /* labels for mono mux outputs */ 3317 static const char * const stac92xx_mono_labels[4] = { 3318 "DAC0", "DAC1", "Mixer", "DAC2" 3319 }; 3320 3321 /* create mono mux for mono out on capable codecs */ 3322 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec) 3323 { 3324 struct sigmatel_spec *spec = codec->spec; 3325 struct hda_input_mux *mono_mux = &spec->private_mono_mux; 3326 int i, num_cons; 3327 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)]; 3328 3329 num_cons = snd_hda_get_connections(codec, 3330 spec->mono_nid, 3331 con_lst, 3332 HDA_MAX_NUM_INPUTS); 3333 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels)) 3334 return -EINVAL; 3335 3336 for (i = 0; i < num_cons; i++) 3337 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i, 3338 NULL); 3339 3340 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX, 3341 "Mono Mux", spec->mono_nid); 3342 } 3343 3344 /* create PC beep volume controls */ 3345 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec, 3346 hda_nid_t nid) 3347 { 3348 struct sigmatel_spec *spec = codec->spec; 3349 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3350 int err, type = STAC_CTL_WIDGET_MUTE_BEEP; 3351 3352 if (spec->anabeep_nid == nid) 3353 type = STAC_CTL_WIDGET_MUTE; 3354 3355 /* check for mute support for the the amp */ 3356 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) { 3357 err = stac92xx_add_control(spec, type, 3358 "Beep Playback Switch", 3359 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); 3360 if (err < 0) 3361 return err; 3362 } 3363 3364 /* check to see if there is volume support for the amp */ 3365 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) { 3366 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, 3367 "Beep Playback Volume", 3368 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); 3369 if (err < 0) 3370 return err; 3371 } 3372 return 0; 3373 } 3374 3375 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3376 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info 3377 3378 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol, 3379 struct snd_ctl_elem_value *ucontrol) 3380 { 3381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3382 ucontrol->value.integer.value[0] = codec->beep->enabled; 3383 return 0; 3384 } 3385 3386 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol, 3387 struct snd_ctl_elem_value *ucontrol) 3388 { 3389 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3390 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]); 3391 } 3392 3393 static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = { 3394 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3395 .info = stac92xx_dig_beep_switch_info, 3396 .get = stac92xx_dig_beep_switch_get, 3397 .put = stac92xx_dig_beep_switch_put, 3398 }; 3399 3400 static int stac92xx_beep_switch_ctl(struct hda_codec *codec) 3401 { 3402 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl, 3403 0, "Beep Playback Switch", 0); 3404 } 3405 #endif 3406 3407 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec) 3408 { 3409 struct sigmatel_spec *spec = codec->spec; 3410 int i, j, err = 0; 3411 3412 for (i = 0; i < spec->num_muxes; i++) { 3413 hda_nid_t nid; 3414 unsigned int wcaps; 3415 unsigned long val; 3416 3417 nid = spec->mux_nids[i]; 3418 wcaps = get_wcaps(codec, nid); 3419 if (!(wcaps & AC_WCAP_OUT_AMP)) 3420 continue; 3421 3422 /* check whether already the same control was created as 3423 * normal Capture Volume. 3424 */ 3425 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3426 for (j = 0; j < spec->num_caps; j++) { 3427 if (spec->capvols[j] == val) 3428 break; 3429 } 3430 if (j < spec->num_caps) 3431 continue; 3432 3433 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i, 3434 "Mux Capture Volume", val); 3435 if (err < 0) 3436 return err; 3437 } 3438 return 0; 3439 }; 3440 3441 static const char * const stac92xx_spdif_labels[3] = { 3442 "Digital Playback", "Analog Mux 1", "Analog Mux 2", 3443 }; 3444 3445 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec) 3446 { 3447 struct sigmatel_spec *spec = codec->spec; 3448 struct hda_input_mux *spdif_mux = &spec->private_smux; 3449 const char * const *labels = spec->spdif_labels; 3450 int i, num_cons; 3451 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; 3452 3453 num_cons = snd_hda_get_connections(codec, 3454 spec->smux_nids[0], 3455 con_lst, 3456 HDA_MAX_NUM_INPUTS); 3457 if (num_cons <= 0) 3458 return -EINVAL; 3459 3460 if (!labels) 3461 labels = stac92xx_spdif_labels; 3462 3463 for (i = 0; i < num_cons; i++) 3464 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL); 3465 3466 return 0; 3467 } 3468 3469 /* labels for dmic mux inputs */ 3470 static const char * const stac92xx_dmic_labels[5] = { 3471 "Analog Inputs", "Digital Mic 1", "Digital Mic 2", 3472 "Digital Mic 3", "Digital Mic 4" 3473 }; 3474 3475 static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux, 3476 int idx) 3477 { 3478 hda_nid_t conn[HDA_MAX_NUM_INPUTS]; 3479 int nums; 3480 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); 3481 if (idx >= 0 && idx < nums) 3482 return conn[idx]; 3483 return 0; 3484 } 3485 3486 /* look for NID recursively */ 3487 #define get_connection_index(codec, mux, nid) \ 3488 snd_hda_get_conn_index(codec, mux, nid, 1) 3489 3490 /* create a volume assigned to the given pin (only if supported) */ 3491 /* return 1 if the volume control is created */ 3492 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, 3493 const char *label, int idx, int direction) 3494 { 3495 unsigned int caps, nums; 3496 char name[32]; 3497 int err; 3498 3499 if (direction == HDA_OUTPUT) 3500 caps = AC_WCAP_OUT_AMP; 3501 else 3502 caps = AC_WCAP_IN_AMP; 3503 if (!(get_wcaps(codec, nid) & caps)) 3504 return 0; 3505 caps = query_amp_caps(codec, nid, direction); 3506 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 3507 if (!nums) 3508 return 0; 3509 snprintf(name, sizeof(name), "%s Capture Volume", label); 3510 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name, 3511 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction)); 3512 if (err < 0) 3513 return err; 3514 return 1; 3515 } 3516 3517 /* create playback/capture controls for input pins on dmic capable codecs */ 3518 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, 3519 const struct auto_pin_cfg *cfg) 3520 { 3521 struct sigmatel_spec *spec = codec->spec; 3522 struct hda_input_mux *imux = &spec->private_imux; 3523 struct hda_input_mux *dimux = &spec->private_dimux; 3524 int err, i; 3525 unsigned int def_conf; 3526 3527 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL); 3528 3529 for (i = 0; i < spec->num_dmics; i++) { 3530 hda_nid_t nid; 3531 int index, type_idx; 3532 char label[32]; 3533 3534 nid = spec->dmic_nids[i]; 3535 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 3536 continue; 3537 def_conf = snd_hda_codec_get_pincfg(codec, nid); 3538 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 3539 continue; 3540 3541 index = get_connection_index(codec, spec->dmux_nids[0], nid); 3542 if (index < 0) 3543 continue; 3544 3545 snd_hda_get_pin_label(codec, nid, &spec->autocfg, 3546 label, sizeof(label), NULL); 3547 snd_hda_add_imux_item(dimux, label, index, &type_idx); 3548 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) 3549 snd_hda_add_imux_item(imux, label, index, &type_idx); 3550 3551 err = create_elem_capture_vol(codec, nid, label, type_idx, 3552 HDA_INPUT); 3553 if (err < 0) 3554 return err; 3555 if (!err) { 3556 err = create_elem_capture_vol(codec, nid, label, 3557 type_idx, HDA_OUTPUT); 3558 if (err < 0) 3559 return err; 3560 if (!err) { 3561 nid = get_connected_node(codec, 3562 spec->dmux_nids[0], index); 3563 if (nid) 3564 err = create_elem_capture_vol(codec, 3565 nid, label, 3566 type_idx, HDA_INPUT); 3567 if (err < 0) 3568 return err; 3569 } 3570 } 3571 } 3572 3573 return 0; 3574 } 3575 3576 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid, 3577 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock) 3578 { 3579 unsigned int cfg; 3580 unsigned int type; 3581 3582 if (!nid) 3583 return 0; 3584 cfg = snd_hda_codec_get_pincfg(codec, nid); 3585 type = get_defcfg_device(cfg); 3586 switch (snd_hda_get_input_pin_attr(cfg)) { 3587 case INPUT_PIN_ATTR_INT: 3588 if (*fixed) 3589 return 1; /* already occupied */ 3590 if (type != AC_JACK_MIC_IN) 3591 return 1; /* invalid type */ 3592 *fixed = nid; 3593 break; 3594 case INPUT_PIN_ATTR_UNUSED: 3595 break; 3596 case INPUT_PIN_ATTR_DOCK: 3597 if (*dock) 3598 return 1; /* already occupied */ 3599 if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN) 3600 return 1; /* invalid type */ 3601 *dock = nid; 3602 break; 3603 default: 3604 if (*ext) 3605 return 1; /* already occupied */ 3606 if (type != AC_JACK_MIC_IN) 3607 return 1; /* invalid type */ 3608 *ext = nid; 3609 break; 3610 } 3611 return 0; 3612 } 3613 3614 static int set_mic_route(struct hda_codec *codec, 3615 struct sigmatel_mic_route *mic, 3616 hda_nid_t pin) 3617 { 3618 struct sigmatel_spec *spec = codec->spec; 3619 struct auto_pin_cfg *cfg = &spec->autocfg; 3620 int i; 3621 3622 mic->pin = pin; 3623 if (pin == 0) 3624 return 0; 3625 for (i = 0; i < cfg->num_inputs; i++) { 3626 if (pin == cfg->inputs[i].pin) 3627 break; 3628 } 3629 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) { 3630 /* analog pin */ 3631 i = get_connection_index(codec, spec->mux_nids[0], pin); 3632 if (i < 0) 3633 return -1; 3634 mic->mux_idx = i; 3635 mic->dmux_idx = -1; 3636 if (spec->dmux_nids) 3637 mic->dmux_idx = get_connection_index(codec, 3638 spec->dmux_nids[0], 3639 spec->mux_nids[0]); 3640 } else if (spec->dmux_nids) { 3641 /* digital pin */ 3642 i = get_connection_index(codec, spec->dmux_nids[0], pin); 3643 if (i < 0) 3644 return -1; 3645 mic->dmux_idx = i; 3646 mic->mux_idx = -1; 3647 if (spec->mux_nids) 3648 mic->mux_idx = get_connection_index(codec, 3649 spec->mux_nids[0], 3650 spec->dmux_nids[0]); 3651 } 3652 return 0; 3653 } 3654 3655 /* return non-zero if the device is for automatic mic switch */ 3656 static int stac_check_auto_mic(struct hda_codec *codec) 3657 { 3658 struct sigmatel_spec *spec = codec->spec; 3659 struct auto_pin_cfg *cfg = &spec->autocfg; 3660 hda_nid_t fixed, ext, dock; 3661 int i; 3662 3663 fixed = ext = dock = 0; 3664 for (i = 0; i < cfg->num_inputs; i++) 3665 if (check_mic_pin(codec, cfg->inputs[i].pin, 3666 &fixed, &ext, &dock)) 3667 return 0; 3668 for (i = 0; i < spec->num_dmics; i++) 3669 if (check_mic_pin(codec, spec->dmic_nids[i], 3670 &fixed, &ext, &dock)) 3671 return 0; 3672 if (!fixed || (!ext && !dock)) 3673 return 0; /* no input to switch */ 3674 if (!is_jack_detectable(codec, ext)) 3675 return 0; /* no unsol support */ 3676 if (set_mic_route(codec, &spec->ext_mic, ext) || 3677 set_mic_route(codec, &spec->int_mic, fixed) || 3678 set_mic_route(codec, &spec->dock_mic, dock)) 3679 return 0; /* something is wrong */ 3680 return 1; 3681 } 3682 3683 /* create playback/capture controls for input pins */ 3684 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) 3685 { 3686 struct sigmatel_spec *spec = codec->spec; 3687 struct hda_input_mux *imux = &spec->private_imux; 3688 int i, j; 3689 const char *label; 3690 3691 for (i = 0; i < cfg->num_inputs; i++) { 3692 hda_nid_t nid = cfg->inputs[i].pin; 3693 int index, err, type_idx; 3694 3695 index = -1; 3696 for (j = 0; j < spec->num_muxes; j++) { 3697 index = get_connection_index(codec, spec->mux_nids[j], 3698 nid); 3699 if (index >= 0) 3700 break; 3701 } 3702 if (index < 0) 3703 continue; 3704 3705 label = hda_get_autocfg_input_label(codec, cfg, i); 3706 snd_hda_add_imux_item(imux, label, index, &type_idx); 3707 3708 err = create_elem_capture_vol(codec, nid, 3709 label, type_idx, 3710 HDA_INPUT); 3711 if (err < 0) 3712 return err; 3713 } 3714 spec->num_analog_muxes = imux->num_items; 3715 3716 if (imux->num_items) { 3717 /* 3718 * Set the current input for the muxes. 3719 * The STAC9221 has two input muxes with identical source 3720 * NID lists. Hopefully this won't get confused. 3721 */ 3722 for (i = 0; i < spec->num_muxes; i++) { 3723 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0, 3724 AC_VERB_SET_CONNECT_SEL, 3725 imux->items[0].index); 3726 } 3727 } 3728 3729 return 0; 3730 } 3731 3732 static void stac92xx_auto_init_multi_out(struct hda_codec *codec) 3733 { 3734 struct sigmatel_spec *spec = codec->spec; 3735 int i; 3736 3737 for (i = 0; i < spec->autocfg.line_outs; i++) { 3738 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3739 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 3740 } 3741 } 3742 3743 static void stac92xx_auto_init_hp_out(struct hda_codec *codec) 3744 { 3745 struct sigmatel_spec *spec = codec->spec; 3746 int i; 3747 3748 for (i = 0; i < spec->autocfg.hp_outs; i++) { 3749 hda_nid_t pin; 3750 pin = spec->autocfg.hp_pins[i]; 3751 if (pin) /* connect to front */ 3752 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 3753 } 3754 for (i = 0; i < spec->autocfg.speaker_outs; i++) { 3755 hda_nid_t pin; 3756 pin = spec->autocfg.speaker_pins[i]; 3757 if (pin) /* connect to front */ 3758 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN); 3759 } 3760 } 3761 3762 static int is_dual_headphones(struct hda_codec *codec) 3763 { 3764 struct sigmatel_spec *spec = codec->spec; 3765 int i, valid_hps; 3766 3767 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT || 3768 spec->autocfg.hp_outs <= 1) 3769 return 0; 3770 valid_hps = 0; 3771 for (i = 0; i < spec->autocfg.hp_outs; i++) { 3772 hda_nid_t nid = spec->autocfg.hp_pins[i]; 3773 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid); 3774 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE) 3775 continue; 3776 valid_hps++; 3777 } 3778 return (valid_hps > 1); 3779 } 3780 3781 3782 static int stac92xx_parse_auto_config(struct hda_codec *codec) 3783 { 3784 struct sigmatel_spec *spec = codec->spec; 3785 hda_nid_t dig_out = 0, dig_in = 0; 3786 int hp_swap = 0; 3787 int i, err; 3788 3789 if ((err = snd_hda_parse_pin_def_config(codec, 3790 &spec->autocfg, 3791 spec->dmic_nids)) < 0) 3792 return err; 3793 if (! spec->autocfg.line_outs) 3794 return 0; /* can't find valid pin config */ 3795 3796 /* If we have no real line-out pin and multiple hp-outs, HPs should 3797 * be set up as multi-channel outputs. 3798 */ 3799 if (is_dual_headphones(codec)) { 3800 /* Copy hp_outs to line_outs, backup line_outs in 3801 * speaker_outs so that the following routines can handle 3802 * HP pins as primary outputs. 3803 */ 3804 snd_printdd("stac92xx: Enabling multi-HPs workaround\n"); 3805 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins, 3806 sizeof(spec->autocfg.line_out_pins)); 3807 spec->autocfg.speaker_outs = spec->autocfg.line_outs; 3808 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins, 3809 sizeof(spec->autocfg.hp_pins)); 3810 spec->autocfg.line_outs = spec->autocfg.hp_outs; 3811 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT; 3812 spec->autocfg.hp_outs = 0; 3813 hp_swap = 1; 3814 } 3815 if (spec->autocfg.mono_out_pin) { 3816 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) & 3817 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP); 3818 u32 caps = query_amp_caps(codec, 3819 spec->autocfg.mono_out_pin, dir); 3820 hda_nid_t conn_list[1]; 3821 3822 /* get the mixer node and then the mono mux if it exists */ 3823 if (snd_hda_get_connections(codec, 3824 spec->autocfg.mono_out_pin, conn_list, 1) && 3825 snd_hda_get_connections(codec, conn_list[0], 3826 conn_list, 1) > 0) { 3827 3828 int wcaps = get_wcaps(codec, conn_list[0]); 3829 int wid_type = get_wcaps_type(wcaps); 3830 /* LR swap check, some stac925x have a mux that 3831 * changes the DACs output path instead of the 3832 * mono-mux path. 3833 */ 3834 if (wid_type == AC_WID_AUD_SEL && 3835 !(wcaps & AC_WCAP_LR_SWAP)) 3836 spec->mono_nid = conn_list[0]; 3837 } 3838 if (dir) { 3839 hda_nid_t nid = spec->autocfg.mono_out_pin; 3840 3841 /* most mono outs have a least a mute/unmute switch */ 3842 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT; 3843 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, 3844 "Mono Playback Switch", 3845 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir)); 3846 if (err < 0) 3847 return err; 3848 /* check for volume support for the amp */ 3849 if ((caps & AC_AMPCAP_NUM_STEPS) 3850 >> AC_AMPCAP_NUM_STEPS_SHIFT) { 3851 err = stac92xx_add_control(spec, 3852 STAC_CTL_WIDGET_VOL, 3853 "Mono Playback Volume", 3854 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir)); 3855 if (err < 0) 3856 return err; 3857 } 3858 } 3859 3860 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin, 3861 AC_PINCTL_OUT_EN); 3862 } 3863 3864 if (!spec->multiout.num_dacs) { 3865 err = stac92xx_auto_fill_dac_nids(codec); 3866 if (err < 0) 3867 return err; 3868 err = stac92xx_auto_create_multi_out_ctls(codec, 3869 &spec->autocfg); 3870 if (err < 0) 3871 return err; 3872 } 3873 3874 /* setup analog beep controls */ 3875 if (spec->anabeep_nid > 0) { 3876 err = stac92xx_auto_create_beep_ctls(codec, 3877 spec->anabeep_nid); 3878 if (err < 0) 3879 return err; 3880 } 3881 3882 /* setup digital beep controls and input device */ 3883 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3884 if (spec->digbeep_nid > 0) { 3885 hda_nid_t nid = spec->digbeep_nid; 3886 unsigned int caps; 3887 3888 err = stac92xx_auto_create_beep_ctls(codec, nid); 3889 if (err < 0) 3890 return err; 3891 err = snd_hda_attach_beep_device(codec, nid); 3892 if (err < 0) 3893 return err; 3894 if (codec->beep) { 3895 /* IDT/STAC codecs have linear beep tone parameter */ 3896 codec->beep->linear_tone = spec->linear_tone_beep; 3897 /* if no beep switch is available, make its own one */ 3898 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3899 if (!(caps & AC_AMPCAP_MUTE)) { 3900 err = stac92xx_beep_switch_ctl(codec); 3901 if (err < 0) 3902 return err; 3903 } 3904 } 3905 } 3906 #endif 3907 3908 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg); 3909 if (err < 0) 3910 return err; 3911 3912 /* All output parsing done, now restore the swapped hp pins */ 3913 if (hp_swap) { 3914 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins, 3915 sizeof(spec->autocfg.hp_pins)); 3916 spec->autocfg.hp_outs = spec->autocfg.line_outs; 3917 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT; 3918 spec->autocfg.line_outs = 0; 3919 } 3920 3921 if (stac_check_auto_mic(codec)) { 3922 spec->auto_mic = 1; 3923 /* only one capture for auto-mic */ 3924 spec->num_adcs = 1; 3925 spec->num_caps = 1; 3926 spec->num_muxes = 1; 3927 } 3928 3929 for (i = 0; i < spec->num_caps; i++) { 3930 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i], 3931 spec->capsws[i], i); 3932 if (err < 0) 3933 return err; 3934 } 3935 3936 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg); 3937 if (err < 0) 3938 return err; 3939 3940 if (spec->mono_nid > 0) { 3941 err = stac92xx_auto_create_mono_output_ctls(codec); 3942 if (err < 0) 3943 return err; 3944 } 3945 if (spec->num_dmics > 0 && !spec->dinput_mux) 3946 if ((err = stac92xx_auto_create_dmic_input_ctls(codec, 3947 &spec->autocfg)) < 0) 3948 return err; 3949 if (spec->num_muxes > 0) { 3950 err = stac92xx_auto_create_mux_input_ctls(codec); 3951 if (err < 0) 3952 return err; 3953 } 3954 if (spec->num_smuxes > 0) { 3955 err = stac92xx_auto_create_spdif_mux_ctls(codec); 3956 if (err < 0) 3957 return err; 3958 } 3959 3960 err = stac92xx_add_input_source(spec); 3961 if (err < 0) 3962 return err; 3963 3964 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 3965 if (spec->multiout.max_channels > 2) 3966 spec->surr_switch = 1; 3967 3968 /* find digital out and in converters */ 3969 for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) { 3970 unsigned int wid_caps = get_wcaps(codec, i); 3971 if (wid_caps & AC_WCAP_DIGITAL) { 3972 switch (get_wcaps_type(wid_caps)) { 3973 case AC_WID_AUD_OUT: 3974 if (!dig_out) 3975 dig_out = i; 3976 break; 3977 case AC_WID_AUD_IN: 3978 if (!dig_in) 3979 dig_in = i; 3980 break; 3981 } 3982 } 3983 } 3984 if (spec->autocfg.dig_outs) 3985 spec->multiout.dig_out_nid = dig_out; 3986 if (dig_in && spec->autocfg.dig_in_pin) 3987 spec->dig_in_nid = dig_in; 3988 3989 if (spec->kctls.list) 3990 spec->mixers[spec->num_mixers++] = spec->kctls.list; 3991 3992 spec->input_mux = &spec->private_imux; 3993 if (!spec->dinput_mux) 3994 spec->dinput_mux = &spec->private_dimux; 3995 spec->sinput_mux = &spec->private_smux; 3996 spec->mono_mux = &spec->private_mono_mux; 3997 return 1; 3998 } 3999 4000 /* add playback controls for HP output */ 4001 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec, 4002 struct auto_pin_cfg *cfg) 4003 { 4004 struct sigmatel_spec *spec = codec->spec; 4005 hda_nid_t pin = cfg->hp_pins[0]; 4006 4007 if (! pin) 4008 return 0; 4009 4010 if (is_jack_detectable(codec, pin)) 4011 spec->hp_detect = 1; 4012 4013 return 0; 4014 } 4015 4016 /* add playback controls for LFE output */ 4017 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec, 4018 struct auto_pin_cfg *cfg) 4019 { 4020 struct sigmatel_spec *spec = codec->spec; 4021 int err; 4022 hda_nid_t lfe_pin = 0x0; 4023 int i; 4024 4025 /* 4026 * search speaker outs and line outs for a mono speaker pin 4027 * with an amp. If one is found, add LFE controls 4028 * for it. 4029 */ 4030 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) { 4031 hda_nid_t pin = spec->autocfg.speaker_pins[i]; 4032 unsigned int wcaps = get_wcaps(codec, pin); 4033 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 4034 if (wcaps == AC_WCAP_OUT_AMP) 4035 /* found a mono speaker with an amp, must be lfe */ 4036 lfe_pin = pin; 4037 } 4038 4039 /* if speaker_outs is 0, then speakers may be in line_outs */ 4040 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) { 4041 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) { 4042 hda_nid_t pin = spec->autocfg.line_out_pins[i]; 4043 unsigned int defcfg; 4044 defcfg = snd_hda_codec_get_pincfg(codec, pin); 4045 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) { 4046 unsigned int wcaps = get_wcaps(codec, pin); 4047 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 4048 if (wcaps == AC_WCAP_OUT_AMP) 4049 /* found a mono speaker with an amp, 4050 must be lfe */ 4051 lfe_pin = pin; 4052 } 4053 } 4054 } 4055 4056 if (lfe_pin) { 4057 err = create_controls(codec, "LFE", lfe_pin, 1); 4058 if (err < 0) 4059 return err; 4060 } 4061 4062 return 0; 4063 } 4064 4065 static int stac9200_parse_auto_config(struct hda_codec *codec) 4066 { 4067 struct sigmatel_spec *spec = codec->spec; 4068 int err; 4069 4070 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) 4071 return err; 4072 4073 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) 4074 return err; 4075 4076 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0) 4077 return err; 4078 4079 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0) 4080 return err; 4081 4082 if (spec->num_muxes > 0) { 4083 err = stac92xx_auto_create_mux_input_ctls(codec); 4084 if (err < 0) 4085 return err; 4086 } 4087 4088 err = stac92xx_add_input_source(spec); 4089 if (err < 0) 4090 return err; 4091 4092 if (spec->autocfg.dig_outs) 4093 spec->multiout.dig_out_nid = 0x05; 4094 if (spec->autocfg.dig_in_pin) 4095 spec->dig_in_nid = 0x04; 4096 4097 if (spec->kctls.list) 4098 spec->mixers[spec->num_mixers++] = spec->kctls.list; 4099 4100 spec->input_mux = &spec->private_imux; 4101 spec->dinput_mux = &spec->private_dimux; 4102 4103 return 1; 4104 } 4105 4106 /* 4107 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a 4108 * funky external mute control using GPIO pins. 4109 */ 4110 4111 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask, 4112 unsigned int dir_mask, unsigned int data) 4113 { 4114 unsigned int gpiostate, gpiomask, gpiodir; 4115 4116 snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data); 4117 4118 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 4119 AC_VERB_GET_GPIO_DATA, 0); 4120 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask); 4121 4122 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 4123 AC_VERB_GET_GPIO_MASK, 0); 4124 gpiomask |= mask; 4125 4126 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 4127 AC_VERB_GET_GPIO_DIRECTION, 0); 4128 gpiodir |= dir_mask; 4129 4130 /* Configure GPIOx as CMOS */ 4131 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0); 4132 4133 snd_hda_codec_write(codec, codec->afg, 0, 4134 AC_VERB_SET_GPIO_MASK, gpiomask); 4135 snd_hda_codec_read(codec, codec->afg, 0, 4136 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */ 4137 4138 msleep(1); 4139 4140 snd_hda_codec_read(codec, codec->afg, 0, 4141 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */ 4142 } 4143 4144 static int stac_add_event(struct hda_codec *codec, hda_nid_t nid, 4145 unsigned char type, int data) 4146 { 4147 struct hda_jack_tbl *event; 4148 4149 event = snd_hda_jack_tbl_new(codec, nid); 4150 if (!event) 4151 return -ENOMEM; 4152 event->action = type; 4153 event->private_data = data; 4154 4155 return 0; 4156 } 4157 4158 /* check if given nid is a valid pin and no other events are assigned 4159 * to it. If OK, assign the event, set the unsol flag, and returns 1. 4160 * Otherwise, returns zero. 4161 */ 4162 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid, 4163 unsigned int type) 4164 { 4165 struct hda_jack_tbl *event; 4166 4167 if (!is_jack_detectable(codec, nid)) 4168 return 0; 4169 event = snd_hda_jack_tbl_new(codec, nid); 4170 if (!event) 4171 return -ENOMEM; 4172 if (event->action && event->action != type) 4173 return 0; 4174 event->action = type; 4175 snd_hda_jack_detect_enable(codec, nid, 0); 4176 return 1; 4177 } 4178 4179 static int is_nid_out_jack_pin(struct auto_pin_cfg *cfg, hda_nid_t nid) 4180 { 4181 int i; 4182 for (i = 0; i < cfg->hp_outs; i++) 4183 if (cfg->hp_pins[i] == nid) 4184 return 1; /* nid is a HP-Out */ 4185 for (i = 0; i < cfg->line_outs; i++) 4186 if (cfg->line_out_pins[i] == nid) 4187 return 1; /* nid is a line-Out */ 4188 return 0; /* nid is not a HP-Out */ 4189 }; 4190 4191 static void stac92xx_power_down(struct hda_codec *codec) 4192 { 4193 struct sigmatel_spec *spec = codec->spec; 4194 4195 /* power down inactive DACs */ 4196 const hda_nid_t *dac; 4197 for (dac = spec->dac_list; *dac; dac++) 4198 if (!check_all_dac_nids(spec, *dac)) 4199 snd_hda_codec_write(codec, *dac, 0, 4200 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 4201 } 4202 4203 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid, 4204 int enable); 4205 4206 static inline int get_int_hint(struct hda_codec *codec, const char *key, 4207 int *valp) 4208 { 4209 const char *p; 4210 p = snd_hda_get_hint(codec, key); 4211 if (p) { 4212 unsigned long val; 4213 if (!strict_strtoul(p, 0, &val)) { 4214 *valp = val; 4215 return 1; 4216 } 4217 } 4218 return 0; 4219 } 4220 4221 /* override some hints from the hwdep entry */ 4222 static void stac_store_hints(struct hda_codec *codec) 4223 { 4224 struct sigmatel_spec *spec = codec->spec; 4225 int val; 4226 4227 val = snd_hda_get_bool_hint(codec, "hp_detect"); 4228 if (val >= 0) 4229 spec->hp_detect = val; 4230 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) { 4231 spec->eapd_mask = spec->gpio_dir = spec->gpio_data = 4232 spec->gpio_mask; 4233 } 4234 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir)) 4235 spec->gpio_mask &= spec->gpio_mask; 4236 if (get_int_hint(codec, "gpio_data", &spec->gpio_data)) 4237 spec->gpio_dir &= spec->gpio_mask; 4238 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask)) 4239 spec->eapd_mask &= spec->gpio_mask; 4240 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute)) 4241 spec->gpio_mute &= spec->gpio_mask; 4242 val = snd_hda_get_bool_hint(codec, "eapd_switch"); 4243 if (val >= 0) 4244 spec->eapd_switch = val; 4245 } 4246 4247 static void stac_issue_unsol_events(struct hda_codec *codec, int num_pins, 4248 const hda_nid_t *pins) 4249 { 4250 while (num_pins--) 4251 stac_issue_unsol_event(codec, *pins++); 4252 } 4253 4254 /* fake event to set up pins */ 4255 static void stac_fake_hp_events(struct hda_codec *codec) 4256 { 4257 struct sigmatel_spec *spec = codec->spec; 4258 4259 if (spec->autocfg.hp_outs) 4260 stac_issue_unsol_events(codec, spec->autocfg.hp_outs, 4261 spec->autocfg.hp_pins); 4262 if (spec->autocfg.line_outs && 4263 spec->autocfg.line_out_pins[0] != spec->autocfg.hp_pins[0]) 4264 stac_issue_unsol_events(codec, spec->autocfg.line_outs, 4265 spec->autocfg.line_out_pins); 4266 } 4267 4268 static int stac92xx_init(struct hda_codec *codec) 4269 { 4270 struct sigmatel_spec *spec = codec->spec; 4271 struct auto_pin_cfg *cfg = &spec->autocfg; 4272 unsigned int gpio; 4273 int i; 4274 4275 if (spec->init) 4276 snd_hda_sequence_write(codec, spec->init); 4277 4278 /* power down adcs initially */ 4279 if (spec->powerdown_adcs) 4280 for (i = 0; i < spec->num_adcs; i++) 4281 snd_hda_codec_write(codec, 4282 spec->adc_nids[i], 0, 4283 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 4284 4285 /* override some hints */ 4286 stac_store_hints(codec); 4287 4288 /* set up GPIO */ 4289 gpio = spec->gpio_data; 4290 /* turn on EAPD statically when spec->eapd_switch isn't set. 4291 * otherwise, unsol event will turn it on/off dynamically 4292 */ 4293 if (!spec->eapd_switch) 4294 gpio |= spec->eapd_mask; 4295 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio); 4296 4297 /* set up pins */ 4298 if (spec->hp_detect) { 4299 /* Enable unsolicited responses on the HP widget */ 4300 for (i = 0; i < cfg->hp_outs; i++) { 4301 hda_nid_t nid = cfg->hp_pins[i]; 4302 enable_pin_detect(codec, nid, STAC_HP_EVENT); 4303 } 4304 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && 4305 cfg->speaker_outs > 0) { 4306 /* enable pin-detect for line-outs as well */ 4307 for (i = 0; i < cfg->line_outs; i++) { 4308 hda_nid_t nid = cfg->line_out_pins[i]; 4309 enable_pin_detect(codec, nid, STAC_LO_EVENT); 4310 } 4311 } 4312 4313 /* force to enable the first line-out; the others are set up 4314 * in unsol_event 4315 */ 4316 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0], 4317 AC_PINCTL_OUT_EN); 4318 /* fake event to set up pins */ 4319 stac_fake_hp_events(codec); 4320 } else { 4321 stac92xx_auto_init_multi_out(codec); 4322 stac92xx_auto_init_hp_out(codec); 4323 for (i = 0; i < cfg->hp_outs; i++) 4324 stac_toggle_power_map(codec, cfg->hp_pins[i], 1); 4325 } 4326 if (spec->auto_mic) { 4327 /* initialize connection to analog input */ 4328 if (spec->dmux_nids) 4329 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0, 4330 AC_VERB_SET_CONNECT_SEL, 0); 4331 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT)) 4332 stac_issue_unsol_event(codec, spec->ext_mic.pin); 4333 if (enable_pin_detect(codec, spec->dock_mic.pin, 4334 STAC_MIC_EVENT)) 4335 stac_issue_unsol_event(codec, spec->dock_mic.pin); 4336 } 4337 for (i = 0; i < cfg->num_inputs; i++) { 4338 hda_nid_t nid = cfg->inputs[i].pin; 4339 int type = cfg->inputs[i].type; 4340 unsigned int pinctl, conf; 4341 if (type == AUTO_PIN_MIC) { 4342 /* for mic pins, force to initialize */ 4343 pinctl = snd_hda_get_default_vref(codec, nid); 4344 pinctl |= AC_PINCTL_IN_EN; 4345 stac92xx_auto_set_pinctl(codec, nid, pinctl); 4346 } else { 4347 pinctl = snd_hda_codec_read(codec, nid, 0, 4348 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4349 /* if PINCTL already set then skip */ 4350 /* Also, if both INPUT and OUTPUT are set, 4351 * it must be a BIOS bug; need to override, too 4352 */ 4353 if (!(pinctl & AC_PINCTL_IN_EN) || 4354 (pinctl & AC_PINCTL_OUT_EN)) { 4355 pinctl &= ~AC_PINCTL_OUT_EN; 4356 pinctl |= AC_PINCTL_IN_EN; 4357 stac92xx_auto_set_pinctl(codec, nid, pinctl); 4358 } 4359 } 4360 conf = snd_hda_codec_get_pincfg(codec, nid); 4361 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) { 4362 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT)) 4363 stac_issue_unsol_event(codec, nid); 4364 } 4365 } 4366 for (i = 0; i < spec->num_dmics; i++) 4367 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i], 4368 AC_PINCTL_IN_EN); 4369 if (cfg->dig_out_pins[0]) 4370 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0], 4371 AC_PINCTL_OUT_EN); 4372 if (cfg->dig_in_pin) 4373 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin, 4374 AC_PINCTL_IN_EN); 4375 for (i = 0; i < spec->num_pwrs; i++) { 4376 hda_nid_t nid = spec->pwr_nids[i]; 4377 unsigned int pinctl, def_conf; 4378 4379 def_conf = snd_hda_codec_get_pincfg(codec, nid); 4380 def_conf = get_defcfg_connect(def_conf); 4381 if (def_conf == AC_JACK_PORT_NONE) { 4382 /* power off unused ports */ 4383 stac_toggle_power_map(codec, nid, 0); 4384 continue; 4385 } 4386 if (def_conf == AC_JACK_PORT_FIXED) { 4387 /* no need for jack detection for fixed pins */ 4388 stac_toggle_power_map(codec, nid, 1); 4389 continue; 4390 } 4391 /* power on when no jack detection is available */ 4392 /* or when the VREF is used for controlling LED */ 4393 if (!spec->hp_detect || 4394 spec->vref_mute_led_nid == nid || 4395 !is_jack_detectable(codec, nid)) { 4396 stac_toggle_power_map(codec, nid, 1); 4397 continue; 4398 } 4399 4400 if (is_nid_out_jack_pin(cfg, nid)) 4401 continue; /* already has an unsol event */ 4402 4403 pinctl = snd_hda_codec_read(codec, nid, 0, 4404 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4405 /* outputs are only ports capable of power management 4406 * any attempts on powering down a input port cause the 4407 * referenced VREF to act quirky. 4408 */ 4409 if (pinctl & AC_PINCTL_IN_EN) { 4410 stac_toggle_power_map(codec, nid, 1); 4411 continue; 4412 } 4413 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT)) { 4414 stac_issue_unsol_event(codec, nid); 4415 continue; 4416 } 4417 /* none of the above, turn the port OFF */ 4418 stac_toggle_power_map(codec, nid, 0); 4419 } 4420 4421 snd_hda_jack_report_sync(codec); 4422 4423 /* sync mute LED */ 4424 if (spec->gpio_led) { 4425 if (spec->vmaster_mute.hook) 4426 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 4427 else /* the very first init call doesn't have vmaster yet */ 4428 stac92xx_update_led_status(codec, false); 4429 } 4430 4431 /* sync the power-map */ 4432 if (spec->num_pwrs) 4433 snd_hda_codec_write(codec, codec->afg, 0, 4434 AC_VERB_IDT_SET_POWER_MAP, 4435 spec->power_map_bits); 4436 if (spec->dac_list) 4437 stac92xx_power_down(codec); 4438 return 0; 4439 } 4440 4441 static void stac92xx_free_kctls(struct hda_codec *codec) 4442 { 4443 struct sigmatel_spec *spec = codec->spec; 4444 4445 if (spec->kctls.list) { 4446 struct snd_kcontrol_new *kctl = spec->kctls.list; 4447 int i; 4448 for (i = 0; i < spec->kctls.used; i++) 4449 kfree(kctl[i].name); 4450 } 4451 snd_array_free(&spec->kctls); 4452 } 4453 4454 static void stac92xx_shutup_pins(struct hda_codec *codec) 4455 { 4456 unsigned int i, def_conf; 4457 4458 if (codec->bus->shutdown) 4459 return; 4460 for (i = 0; i < codec->init_pins.used; i++) { 4461 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 4462 def_conf = snd_hda_codec_get_pincfg(codec, pin->nid); 4463 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) 4464 snd_hda_set_pin_ctl(codec, pin->nid, 0); 4465 } 4466 } 4467 4468 static void stac92xx_shutup(struct hda_codec *codec) 4469 { 4470 struct sigmatel_spec *spec = codec->spec; 4471 4472 stac92xx_shutup_pins(codec); 4473 4474 if (spec->eapd_mask) 4475 stac_gpio_set(codec, spec->gpio_mask, 4476 spec->gpio_dir, spec->gpio_data & 4477 ~spec->eapd_mask); 4478 } 4479 4480 static void stac92xx_free(struct hda_codec *codec) 4481 { 4482 struct sigmatel_spec *spec = codec->spec; 4483 4484 if (! spec) 4485 return; 4486 4487 stac92xx_shutup(codec); 4488 4489 kfree(spec); 4490 snd_hda_detach_beep_device(codec); 4491 } 4492 4493 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid, 4494 unsigned int flag) 4495 { 4496 unsigned int old_ctl, pin_ctl; 4497 4498 pin_ctl = snd_hda_codec_read(codec, nid, 4499 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 4500 4501 if (pin_ctl & AC_PINCTL_IN_EN) { 4502 /* 4503 * we need to check the current set-up direction of 4504 * shared input pins since they can be switched via 4505 * "xxx as Output" mixer switch 4506 */ 4507 struct sigmatel_spec *spec = codec->spec; 4508 if (nid == spec->line_switch || nid == spec->mic_switch) 4509 return; 4510 } 4511 4512 old_ctl = pin_ctl; 4513 /* if setting pin direction bits, clear the current 4514 direction bits first */ 4515 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)) 4516 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 4517 4518 pin_ctl |= flag; 4519 if (old_ctl != pin_ctl) 4520 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl); 4521 } 4522 4523 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid, 4524 unsigned int flag) 4525 { 4526 unsigned int pin_ctl = snd_hda_codec_read(codec, nid, 4527 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 4528 if (pin_ctl & flag) 4529 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag); 4530 } 4531 4532 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid) 4533 { 4534 if (!nid) 4535 return 0; 4536 return snd_hda_jack_detect(codec, nid); 4537 } 4538 4539 static void stac92xx_line_out_detect(struct hda_codec *codec, 4540 int presence) 4541 { 4542 struct sigmatel_spec *spec = codec->spec; 4543 struct auto_pin_cfg *cfg = &spec->autocfg; 4544 int i; 4545 4546 if (cfg->speaker_outs == 0) 4547 return; 4548 4549 for (i = 0; i < cfg->line_outs; i++) { 4550 if (presence) 4551 break; 4552 presence = get_pin_presence(codec, cfg->line_out_pins[i]); 4553 if (presence) { 4554 unsigned int pinctl; 4555 pinctl = snd_hda_codec_read(codec, 4556 cfg->line_out_pins[i], 0, 4557 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4558 if (pinctl & AC_PINCTL_IN_EN) 4559 presence = 0; /* mic- or line-input */ 4560 } 4561 } 4562 4563 if (presence) { 4564 /* disable speakers */ 4565 for (i = 0; i < cfg->speaker_outs; i++) 4566 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i], 4567 AC_PINCTL_OUT_EN); 4568 if (spec->eapd_mask && spec->eapd_switch) 4569 stac_gpio_set(codec, spec->gpio_mask, 4570 spec->gpio_dir, spec->gpio_data & 4571 ~spec->eapd_mask); 4572 } else { 4573 /* enable speakers */ 4574 for (i = 0; i < cfg->speaker_outs; i++) 4575 stac92xx_set_pinctl(codec, cfg->speaker_pins[i], 4576 AC_PINCTL_OUT_EN); 4577 if (spec->eapd_mask && spec->eapd_switch) 4578 stac_gpio_set(codec, spec->gpio_mask, 4579 spec->gpio_dir, spec->gpio_data | 4580 spec->eapd_mask); 4581 } 4582 } 4583 4584 /* return non-zero if the hp-pin of the given array index isn't 4585 * a jack-detection target 4586 */ 4587 static int no_hp_sensing(struct sigmatel_spec *spec, int i) 4588 { 4589 struct auto_pin_cfg *cfg = &spec->autocfg; 4590 4591 /* ignore sensing of shared line and mic jacks */ 4592 if (cfg->hp_pins[i] == spec->line_switch) 4593 return 1; 4594 if (cfg->hp_pins[i] == spec->mic_switch) 4595 return 1; 4596 /* ignore if the pin is set as line-out */ 4597 if (cfg->hp_pins[i] == spec->hp_switch) 4598 return 1; 4599 return 0; 4600 } 4601 4602 static void stac92xx_hp_detect(struct hda_codec *codec) 4603 { 4604 struct sigmatel_spec *spec = codec->spec; 4605 struct auto_pin_cfg *cfg = &spec->autocfg; 4606 int i, presence; 4607 4608 presence = 0; 4609 if (spec->gpio_mute) 4610 presence = !(snd_hda_codec_read(codec, codec->afg, 0, 4611 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute); 4612 4613 for (i = 0; i < cfg->hp_outs; i++) { 4614 if (presence) 4615 break; 4616 if (no_hp_sensing(spec, i)) 4617 continue; 4618 presence = get_pin_presence(codec, cfg->hp_pins[i]); 4619 if (presence) { 4620 unsigned int pinctl; 4621 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0, 4622 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4623 if (pinctl & AC_PINCTL_IN_EN) 4624 presence = 0; /* mic- or line-input */ 4625 } 4626 } 4627 4628 if (presence) { 4629 /* disable lineouts */ 4630 if (spec->hp_switch) 4631 stac92xx_reset_pinctl(codec, spec->hp_switch, 4632 AC_PINCTL_OUT_EN); 4633 for (i = 0; i < cfg->line_outs; i++) 4634 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i], 4635 AC_PINCTL_OUT_EN); 4636 } else { 4637 /* enable lineouts */ 4638 if (spec->hp_switch) 4639 stac92xx_set_pinctl(codec, spec->hp_switch, 4640 AC_PINCTL_OUT_EN); 4641 for (i = 0; i < cfg->line_outs; i++) 4642 stac92xx_set_pinctl(codec, cfg->line_out_pins[i], 4643 AC_PINCTL_OUT_EN); 4644 } 4645 stac92xx_line_out_detect(codec, presence); 4646 /* toggle hp outs */ 4647 for (i = 0; i < cfg->hp_outs; i++) { 4648 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN; 4649 if (no_hp_sensing(spec, i)) 4650 continue; 4651 if (1 /*presence*/) 4652 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val); 4653 #if 0 /* FIXME */ 4654 /* Resetting the pinctl like below may lead to (a sort of) regressions 4655 * on some devices since they use the HP pin actually for line/speaker 4656 * outs although the default pin config shows a different pin (that is 4657 * wrong and useless). 4658 * 4659 * So, it's basically a problem of default pin configs, likely a BIOS issue. 4660 * But, disabling the code below just works around it, and I'm too tired of 4661 * bug reports with such devices... 4662 */ 4663 else 4664 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val); 4665 #endif /* FIXME */ 4666 } 4667 } 4668 4669 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid, 4670 int enable) 4671 { 4672 struct sigmatel_spec *spec = codec->spec; 4673 unsigned int idx, val; 4674 4675 for (idx = 0; idx < spec->num_pwrs; idx++) { 4676 if (spec->pwr_nids[idx] == nid) 4677 break; 4678 } 4679 if (idx >= spec->num_pwrs) 4680 return; 4681 4682 idx = 1 << idx; 4683 4684 val = spec->power_map_bits; 4685 if (enable) 4686 val &= ~idx; 4687 else 4688 val |= idx; 4689 4690 /* power down unused output ports */ 4691 if (val != spec->power_map_bits) { 4692 spec->power_map_bits = val; 4693 snd_hda_codec_write(codec, codec->afg, 0, 4694 AC_VERB_IDT_SET_POWER_MAP, val); 4695 } 4696 } 4697 4698 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid) 4699 { 4700 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid)); 4701 } 4702 4703 /* get the pin connection (fixed, none, etc) */ 4704 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx) 4705 { 4706 struct sigmatel_spec *spec = codec->spec; 4707 unsigned int cfg; 4708 4709 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]); 4710 return get_defcfg_connect(cfg); 4711 } 4712 4713 static int stac92xx_connected_ports(struct hda_codec *codec, 4714 const hda_nid_t *nids, int num_nids) 4715 { 4716 struct sigmatel_spec *spec = codec->spec; 4717 int idx, num; 4718 unsigned int def_conf; 4719 4720 for (num = 0; num < num_nids; num++) { 4721 for (idx = 0; idx < spec->num_pins; idx++) 4722 if (spec->pin_nids[idx] == nids[num]) 4723 break; 4724 if (idx >= spec->num_pins) 4725 break; 4726 def_conf = stac_get_defcfg_connect(codec, idx); 4727 if (def_conf == AC_JACK_PORT_NONE) 4728 break; 4729 } 4730 return num; 4731 } 4732 4733 static void stac92xx_mic_detect(struct hda_codec *codec) 4734 { 4735 struct sigmatel_spec *spec = codec->spec; 4736 struct sigmatel_mic_route *mic; 4737 4738 if (get_pin_presence(codec, spec->ext_mic.pin)) 4739 mic = &spec->ext_mic; 4740 else if (get_pin_presence(codec, spec->dock_mic.pin)) 4741 mic = &spec->dock_mic; 4742 else 4743 mic = &spec->int_mic; 4744 if (mic->dmux_idx >= 0) 4745 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0, 4746 AC_VERB_SET_CONNECT_SEL, 4747 mic->dmux_idx); 4748 if (mic->mux_idx >= 0) 4749 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0, 4750 AC_VERB_SET_CONNECT_SEL, 4751 mic->mux_idx); 4752 } 4753 4754 static void handle_unsol_event(struct hda_codec *codec, 4755 struct hda_jack_tbl *event) 4756 { 4757 struct sigmatel_spec *spec = codec->spec; 4758 int data; 4759 4760 switch (event->action) { 4761 case STAC_HP_EVENT: 4762 case STAC_LO_EVENT: 4763 stac92xx_hp_detect(codec); 4764 break; 4765 case STAC_MIC_EVENT: 4766 stac92xx_mic_detect(codec); 4767 break; 4768 } 4769 4770 switch (event->action) { 4771 case STAC_HP_EVENT: 4772 case STAC_LO_EVENT: 4773 case STAC_MIC_EVENT: 4774 case STAC_INSERT_EVENT: 4775 case STAC_PWR_EVENT: 4776 if (spec->num_pwrs > 0) 4777 stac92xx_pin_sense(codec, event->nid); 4778 4779 switch (codec->subsystem_id) { 4780 case 0x103c308f: 4781 if (event->nid == 0xb) { 4782 int pin = AC_PINCTL_IN_EN; 4783 4784 if (get_pin_presence(codec, 0xa) 4785 && get_pin_presence(codec, 0xb)) 4786 pin |= AC_PINCTL_VREF_80; 4787 if (!get_pin_presence(codec, 0xb)) 4788 pin |= AC_PINCTL_VREF_80; 4789 4790 /* toggle VREF state based on mic + hp pin 4791 * status 4792 */ 4793 stac92xx_auto_set_pinctl(codec, 0x0a, pin); 4794 } 4795 } 4796 break; 4797 case STAC_VREF_EVENT: 4798 data = snd_hda_codec_read(codec, codec->afg, 0, 4799 AC_VERB_GET_GPIO_DATA, 0); 4800 /* toggle VREF state based on GPIOx status */ 4801 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0, 4802 !!(data & (1 << event->private_data))); 4803 break; 4804 } 4805 } 4806 4807 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid) 4808 { 4809 struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid); 4810 if (!event) 4811 return; 4812 handle_unsol_event(codec, event); 4813 } 4814 4815 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res) 4816 { 4817 struct hda_jack_tbl *event; 4818 int tag; 4819 4820 tag = (res >> 26) & 0x7f; 4821 event = snd_hda_jack_tbl_get_from_tag(codec, tag); 4822 if (!event) 4823 return; 4824 event->jack_dirty = 1; 4825 handle_unsol_event(codec, event); 4826 snd_hda_jack_report_sync(codec); 4827 } 4828 4829 static int hp_blike_system(u32 subsystem_id); 4830 4831 static void set_hp_led_gpio(struct hda_codec *codec) 4832 { 4833 struct sigmatel_spec *spec = codec->spec; 4834 unsigned int gpio; 4835 4836 if (spec->gpio_led) 4837 return; 4838 4839 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP); 4840 gpio &= AC_GPIO_IO_COUNT; 4841 if (gpio > 3) 4842 spec->gpio_led = 0x08; /* GPIO 3 */ 4843 else 4844 spec->gpio_led = 0x01; /* GPIO 0 */ 4845 } 4846 4847 /* 4848 * This method searches for the mute LED GPIO configuration 4849 * provided as OEM string in SMBIOS. The format of that string 4850 * is HP_Mute_LED_P_G or HP_Mute_LED_P 4851 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high) 4852 * that corresponds to the NOT muted state of the master volume 4853 * and G is the index of the GPIO to use as the mute LED control (0..9) 4854 * If _G portion is missing it is assigned based on the codec ID 4855 * 4856 * So, HP B-series like systems may have HP_Mute_LED_0 (current models) 4857 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings 4858 * 4859 * 4860 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in 4861 * SMBIOS - at least the ones I have seen do not have them - which include 4862 * my own system (HP Pavilion dv6-1110ax) and my cousin's 4863 * HP Pavilion dv9500t CTO. 4864 * Need more information on whether it is true across the entire series. 4865 * -- kunal 4866 */ 4867 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity) 4868 { 4869 struct sigmatel_spec *spec = codec->spec; 4870 const struct dmi_device *dev = NULL; 4871 4872 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) { 4873 get_int_hint(codec, "gpio_led_polarity", 4874 &spec->gpio_led_polarity); 4875 return 1; 4876 } 4877 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) { 4878 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, 4879 NULL, dev))) { 4880 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", 4881 &spec->gpio_led_polarity, 4882 &spec->gpio_led) == 2) { 4883 unsigned int max_gpio; 4884 max_gpio = snd_hda_param_read(codec, codec->afg, 4885 AC_PAR_GPIO_CAP); 4886 max_gpio &= AC_GPIO_IO_COUNT; 4887 if (spec->gpio_led < max_gpio) 4888 spec->gpio_led = 1 << spec->gpio_led; 4889 else 4890 spec->vref_mute_led_nid = spec->gpio_led; 4891 return 1; 4892 } 4893 if (sscanf(dev->name, "HP_Mute_LED_%d", 4894 &spec->gpio_led_polarity) == 1) { 4895 set_hp_led_gpio(codec); 4896 return 1; 4897 } 4898 /* BIOS bug: unfilled OEM string */ 4899 if (strstr(dev->name, "HP_Mute_LED_P_G")) { 4900 set_hp_led_gpio(codec); 4901 switch (codec->subsystem_id) { 4902 case 0x103c148a: 4903 spec->gpio_led_polarity = 0; 4904 break; 4905 default: 4906 spec->gpio_led_polarity = 1; 4907 break; 4908 } 4909 return 1; 4910 } 4911 } 4912 4913 /* 4914 * Fallback case - if we don't find the DMI strings, 4915 * we statically set the GPIO - if not a B-series system 4916 * and default polarity is provided 4917 */ 4918 if (!hp_blike_system(codec->subsystem_id) && 4919 (default_polarity == 0 || default_polarity == 1)) { 4920 set_hp_led_gpio(codec); 4921 spec->gpio_led_polarity = default_polarity; 4922 return 1; 4923 } 4924 } 4925 return 0; 4926 } 4927 4928 static int hp_blike_system(u32 subsystem_id) 4929 { 4930 switch (subsystem_id) { 4931 case 0x103c1520: 4932 case 0x103c1521: 4933 case 0x103c1523: 4934 case 0x103c1524: 4935 case 0x103c1525: 4936 case 0x103c1722: 4937 case 0x103c1723: 4938 case 0x103c1724: 4939 case 0x103c1725: 4940 case 0x103c1726: 4941 case 0x103c1727: 4942 case 0x103c1728: 4943 case 0x103c1729: 4944 case 0x103c172a: 4945 case 0x103c172b: 4946 case 0x103c307e: 4947 case 0x103c307f: 4948 case 0x103c3080: 4949 case 0x103c3081: 4950 case 0x103c7007: 4951 case 0x103c7008: 4952 return 1; 4953 } 4954 return 0; 4955 } 4956 4957 #ifdef CONFIG_PROC_FS 4958 static void stac92hd_proc_hook(struct snd_info_buffer *buffer, 4959 struct hda_codec *codec, hda_nid_t nid) 4960 { 4961 if (nid == codec->afg) 4962 snd_iprintf(buffer, "Power-Map: 0x%02x\n", 4963 snd_hda_codec_read(codec, nid, 0, 4964 AC_VERB_IDT_GET_POWER_MAP, 0)); 4965 } 4966 4967 static void analog_loop_proc_hook(struct snd_info_buffer *buffer, 4968 struct hda_codec *codec, 4969 unsigned int verb) 4970 { 4971 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n", 4972 snd_hda_codec_read(codec, codec->afg, 0, verb, 0)); 4973 } 4974 4975 /* stac92hd71bxx, stac92hd73xx */ 4976 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer, 4977 struct hda_codec *codec, hda_nid_t nid) 4978 { 4979 stac92hd_proc_hook(buffer, codec, nid); 4980 if (nid == codec->afg) 4981 analog_loop_proc_hook(buffer, codec, 0xfa0); 4982 } 4983 4984 static void stac9205_proc_hook(struct snd_info_buffer *buffer, 4985 struct hda_codec *codec, hda_nid_t nid) 4986 { 4987 if (nid == codec->afg) 4988 analog_loop_proc_hook(buffer, codec, 0xfe0); 4989 } 4990 4991 static void stac927x_proc_hook(struct snd_info_buffer *buffer, 4992 struct hda_codec *codec, hda_nid_t nid) 4993 { 4994 if (nid == codec->afg) 4995 analog_loop_proc_hook(buffer, codec, 0xfeb); 4996 } 4997 #else 4998 #define stac92hd_proc_hook NULL 4999 #define stac92hd7x_proc_hook NULL 5000 #define stac9205_proc_hook NULL 5001 #define stac927x_proc_hook NULL 5002 #endif 5003 5004 #ifdef CONFIG_PM 5005 static int stac92xx_resume(struct hda_codec *codec) 5006 { 5007 stac92xx_init(codec); 5008 snd_hda_codec_resume_amp(codec); 5009 snd_hda_codec_resume_cache(codec); 5010 /* fake event to set up pins again to override cached values */ 5011 stac_fake_hp_events(codec); 5012 return 0; 5013 } 5014 5015 static int stac92xx_suspend(struct hda_codec *codec) 5016 { 5017 stac92xx_shutup(codec); 5018 return 0; 5019 } 5020 5021 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg, 5022 unsigned int power_state) 5023 { 5024 unsigned int afg_power_state = power_state; 5025 struct sigmatel_spec *spec = codec->spec; 5026 5027 if (power_state == AC_PWRST_D3) { 5028 if (spec->vref_mute_led_nid) { 5029 /* with vref-out pin used for mute led control 5030 * codec AFG is prevented from D3 state 5031 */ 5032 afg_power_state = AC_PWRST_D1; 5033 } 5034 /* this delay seems necessary to avoid click noise at power-down */ 5035 msleep(100); 5036 } 5037 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, 5038 afg_power_state); 5039 snd_hda_codec_set_power_to_all(codec, fg, power_state, true); 5040 } 5041 #else 5042 #define stac92xx_suspend NULL 5043 #define stac92xx_resume NULL 5044 #define stac92xx_set_power_state NULL 5045 #endif /* CONFIG_PM */ 5046 5047 /* update mute-LED accoring to the master switch */ 5048 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled) 5049 { 5050 struct sigmatel_spec *spec = codec->spec; 5051 int muted = !enabled; 5052 5053 if (!spec->gpio_led) 5054 return; 5055 5056 /* LED state is inverted on these systems */ 5057 if (spec->gpio_led_polarity) 5058 muted = !muted; 5059 5060 if (!spec->vref_mute_led_nid) { 5061 if (muted) 5062 spec->gpio_data |= spec->gpio_led; 5063 else 5064 spec->gpio_data &= ~spec->gpio_led; 5065 stac_gpio_set(codec, spec->gpio_mask, 5066 spec->gpio_dir, spec->gpio_data); 5067 } else { 5068 spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD; 5069 stac_vrefout_set(codec, spec->vref_mute_led_nid, 5070 spec->vref_led); 5071 } 5072 } 5073 5074 static const struct hda_codec_ops stac92xx_patch_ops = { 5075 .build_controls = stac92xx_build_controls, 5076 .build_pcms = stac92xx_build_pcms, 5077 .init = stac92xx_init, 5078 .free = stac92xx_free, 5079 .unsol_event = stac92xx_unsol_event, 5080 #ifdef CONFIG_PM 5081 .suspend = stac92xx_suspend, 5082 .resume = stac92xx_resume, 5083 #endif 5084 .reboot_notify = stac92xx_shutup, 5085 }; 5086 5087 static int patch_stac9200(struct hda_codec *codec) 5088 { 5089 struct sigmatel_spec *spec; 5090 int err; 5091 5092 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5093 if (spec == NULL) 5094 return -ENOMEM; 5095 5096 codec->no_trigger_sense = 1; 5097 codec->spec = spec; 5098 spec->linear_tone_beep = 1; 5099 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids); 5100 spec->pin_nids = stac9200_pin_nids; 5101 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS, 5102 stac9200_models, 5103 stac9200_cfg_tbl); 5104 if (spec->board_config < 0) 5105 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5106 codec->chip_name); 5107 else 5108 stac92xx_set_config_regs(codec, 5109 stac9200_brd_tbl[spec->board_config]); 5110 5111 spec->multiout.max_channels = 2; 5112 spec->multiout.num_dacs = 1; 5113 spec->multiout.dac_nids = stac9200_dac_nids; 5114 spec->adc_nids = stac9200_adc_nids; 5115 spec->mux_nids = stac9200_mux_nids; 5116 spec->num_muxes = 1; 5117 spec->num_dmics = 0; 5118 spec->num_adcs = 1; 5119 spec->num_pwrs = 0; 5120 5121 if (spec->board_config == STAC_9200_M4 || 5122 spec->board_config == STAC_9200_M4_2 || 5123 spec->board_config == STAC_9200_OQO) 5124 spec->init = stac9200_eapd_init; 5125 else 5126 spec->init = stac9200_core_init; 5127 spec->mixer = stac9200_mixer; 5128 5129 if (spec->board_config == STAC_9200_PANASONIC) { 5130 spec->gpio_mask = spec->gpio_dir = 0x09; 5131 spec->gpio_data = 0x00; 5132 } 5133 5134 err = stac9200_parse_auto_config(codec); 5135 if (err < 0) { 5136 stac92xx_free(codec); 5137 return err; 5138 } 5139 5140 /* CF-74 has no headphone detection, and the driver should *NOT* 5141 * do detection and HP/speaker toggle because the hardware does it. 5142 */ 5143 if (spec->board_config == STAC_9200_PANASONIC) 5144 spec->hp_detect = 0; 5145 5146 codec->patch_ops = stac92xx_patch_ops; 5147 5148 return 0; 5149 } 5150 5151 static int patch_stac925x(struct hda_codec *codec) 5152 { 5153 struct sigmatel_spec *spec; 5154 int err; 5155 5156 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5157 if (spec == NULL) 5158 return -ENOMEM; 5159 5160 codec->no_trigger_sense = 1; 5161 codec->spec = spec; 5162 spec->linear_tone_beep = 1; 5163 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids); 5164 spec->pin_nids = stac925x_pin_nids; 5165 5166 /* Check first for codec ID */ 5167 spec->board_config = snd_hda_check_board_codec_sid_config(codec, 5168 STAC_925x_MODELS, 5169 stac925x_models, 5170 stac925x_codec_id_cfg_tbl); 5171 5172 /* Now checks for PCI ID, if codec ID is not found */ 5173 if (spec->board_config < 0) 5174 spec->board_config = snd_hda_check_board_config(codec, 5175 STAC_925x_MODELS, 5176 stac925x_models, 5177 stac925x_cfg_tbl); 5178 again: 5179 if (spec->board_config < 0) 5180 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5181 codec->chip_name); 5182 else 5183 stac92xx_set_config_regs(codec, 5184 stac925x_brd_tbl[spec->board_config]); 5185 5186 spec->multiout.max_channels = 2; 5187 spec->multiout.num_dacs = 1; 5188 spec->multiout.dac_nids = stac925x_dac_nids; 5189 spec->adc_nids = stac925x_adc_nids; 5190 spec->mux_nids = stac925x_mux_nids; 5191 spec->num_muxes = 1; 5192 spec->num_adcs = 1; 5193 spec->num_pwrs = 0; 5194 switch (codec->vendor_id) { 5195 case 0x83847632: /* STAC9202 */ 5196 case 0x83847633: /* STAC9202D */ 5197 case 0x83847636: /* STAC9251 */ 5198 case 0x83847637: /* STAC9251D */ 5199 spec->num_dmics = STAC925X_NUM_DMICS; 5200 spec->dmic_nids = stac925x_dmic_nids; 5201 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids); 5202 spec->dmux_nids = stac925x_dmux_nids; 5203 break; 5204 default: 5205 spec->num_dmics = 0; 5206 break; 5207 } 5208 5209 spec->init = stac925x_core_init; 5210 spec->mixer = stac925x_mixer; 5211 spec->num_caps = 1; 5212 spec->capvols = stac925x_capvols; 5213 spec->capsws = stac925x_capsws; 5214 5215 err = stac92xx_parse_auto_config(codec); 5216 if (!err) { 5217 if (spec->board_config < 0) { 5218 printk(KERN_WARNING "hda_codec: No auto-config is " 5219 "available, default to model=ref\n"); 5220 spec->board_config = STAC_925x_REF; 5221 goto again; 5222 } 5223 err = -EINVAL; 5224 } 5225 if (err < 0) { 5226 stac92xx_free(codec); 5227 return err; 5228 } 5229 5230 codec->patch_ops = stac92xx_patch_ops; 5231 5232 return 0; 5233 } 5234 5235 static int patch_stac92hd73xx(struct hda_codec *codec) 5236 { 5237 struct sigmatel_spec *spec; 5238 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2]; 5239 int err = 0; 5240 int num_dacs; 5241 5242 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5243 if (spec == NULL) 5244 return -ENOMEM; 5245 5246 codec->no_trigger_sense = 1; 5247 codec->spec = spec; 5248 spec->linear_tone_beep = 0; 5249 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs; 5250 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids); 5251 spec->pin_nids = stac92hd73xx_pin_nids; 5252 spec->board_config = snd_hda_check_board_config(codec, 5253 STAC_92HD73XX_MODELS, 5254 stac92hd73xx_models, 5255 stac92hd73xx_cfg_tbl); 5256 /* check codec subsystem id if not found */ 5257 if (spec->board_config < 0) 5258 spec->board_config = 5259 snd_hda_check_board_codec_sid_config(codec, 5260 STAC_92HD73XX_MODELS, stac92hd73xx_models, 5261 stac92hd73xx_codec_id_cfg_tbl); 5262 again: 5263 if (spec->board_config < 0) 5264 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5265 codec->chip_name); 5266 else 5267 stac92xx_set_config_regs(codec, 5268 stac92hd73xx_brd_tbl[spec->board_config]); 5269 5270 num_dacs = snd_hda_get_connections(codec, 0x0a, 5271 conn, STAC92HD73_DAC_COUNT + 2) - 1; 5272 5273 if (num_dacs < 3 || num_dacs > 5) { 5274 printk(KERN_WARNING "hda_codec: Could not determine " 5275 "number of channels defaulting to DAC count\n"); 5276 num_dacs = STAC92HD73_DAC_COUNT; 5277 } 5278 spec->init = stac92hd73xx_core_init; 5279 switch (num_dacs) { 5280 case 0x3: /* 6 Channel */ 5281 spec->aloopback_ctl = stac92hd73xx_6ch_loopback; 5282 break; 5283 case 0x4: /* 8 Channel */ 5284 spec->aloopback_ctl = stac92hd73xx_8ch_loopback; 5285 break; 5286 case 0x5: /* 10 Channel */ 5287 spec->aloopback_ctl = stac92hd73xx_10ch_loopback; 5288 break; 5289 } 5290 spec->multiout.dac_nids = spec->dac_nids; 5291 5292 spec->aloopback_mask = 0x01; 5293 spec->aloopback_shift = 8; 5294 5295 spec->digbeep_nid = 0x1c; 5296 spec->mux_nids = stac92hd73xx_mux_nids; 5297 spec->adc_nids = stac92hd73xx_adc_nids; 5298 spec->dmic_nids = stac92hd73xx_dmic_nids; 5299 spec->dmux_nids = stac92hd73xx_dmux_nids; 5300 spec->smux_nids = stac92hd73xx_smux_nids; 5301 5302 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids); 5303 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids); 5304 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids); 5305 5306 spec->num_caps = STAC92HD73XX_NUM_CAPS; 5307 spec->capvols = stac92hd73xx_capvols; 5308 spec->capsws = stac92hd73xx_capsws; 5309 5310 switch (spec->board_config) { 5311 case STAC_DELL_EQ: 5312 spec->init = dell_eq_core_init; 5313 /* fallthru */ 5314 case STAC_DELL_M6_AMIC: 5315 case STAC_DELL_M6_DMIC: 5316 case STAC_DELL_M6_BOTH: 5317 spec->num_smuxes = 0; 5318 spec->eapd_switch = 0; 5319 5320 switch (spec->board_config) { 5321 case STAC_DELL_M6_AMIC: /* Analog Mics */ 5322 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5323 spec->num_dmics = 0; 5324 break; 5325 case STAC_DELL_M6_DMIC: /* Digital Mics */ 5326 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5327 spec->num_dmics = 1; 5328 break; 5329 case STAC_DELL_M6_BOTH: /* Both */ 5330 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5331 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5332 spec->num_dmics = 1; 5333 break; 5334 } 5335 break; 5336 case STAC_ALIENWARE_M17X: 5337 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5338 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5339 spec->eapd_switch = 0; 5340 break; 5341 default: 5342 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5343 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5344 spec->eapd_switch = 1; 5345 break; 5346 } 5347 if (spec->board_config != STAC_92HD73XX_REF) { 5348 /* GPIO0 High = Enable EAPD */ 5349 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 5350 spec->gpio_data = 0x01; 5351 } 5352 5353 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids); 5354 spec->pwr_nids = stac92hd73xx_pwr_nids; 5355 5356 err = stac92xx_parse_auto_config(codec); 5357 5358 if (!err) { 5359 if (spec->board_config < 0) { 5360 printk(KERN_WARNING "hda_codec: No auto-config is " 5361 "available, default to model=ref\n"); 5362 spec->board_config = STAC_92HD73XX_REF; 5363 goto again; 5364 } 5365 err = -EINVAL; 5366 } 5367 5368 if (err < 0) { 5369 stac92xx_free(codec); 5370 return err; 5371 } 5372 5373 if (spec->board_config == STAC_92HD73XX_NO_JD) 5374 spec->hp_detect = 0; 5375 5376 codec->patch_ops = stac92xx_patch_ops; 5377 5378 codec->proc_widget_hook = stac92hd7x_proc_hook; 5379 5380 return 0; 5381 } 5382 5383 static int hp_bnb2011_with_dock(struct hda_codec *codec) 5384 { 5385 if (codec->vendor_id != 0x111d7605 && 5386 codec->vendor_id != 0x111d76d1) 5387 return 0; 5388 5389 switch (codec->subsystem_id) { 5390 case 0x103c1618: 5391 case 0x103c1619: 5392 case 0x103c161a: 5393 case 0x103c161b: 5394 case 0x103c161c: 5395 case 0x103c161d: 5396 case 0x103c161e: 5397 case 0x103c161f: 5398 5399 case 0x103c162a: 5400 case 0x103c162b: 5401 5402 case 0x103c1630: 5403 case 0x103c1631: 5404 5405 case 0x103c1633: 5406 case 0x103c1634: 5407 case 0x103c1635: 5408 5409 case 0x103c3587: 5410 case 0x103c3588: 5411 case 0x103c3589: 5412 case 0x103c358a: 5413 5414 case 0x103c3667: 5415 case 0x103c3668: 5416 case 0x103c3669: 5417 5418 return 1; 5419 } 5420 return 0; 5421 } 5422 5423 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid) 5424 { 5425 struct sigmatel_spec *spec = codec->spec; 5426 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 5427 int i; 5428 5429 spec->auto_pin_nids[spec->auto_pin_cnt] = nid; 5430 spec->auto_pin_cnt++; 5431 5432 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN && 5433 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) { 5434 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) { 5435 if (nid == stac92hd83xxx_dmic_nids[i]) { 5436 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid; 5437 spec->auto_dmic_cnt++; 5438 } 5439 } 5440 } 5441 } 5442 5443 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid) 5444 { 5445 struct sigmatel_spec *spec = codec->spec; 5446 5447 spec->auto_adc_nids[spec->auto_adc_cnt] = nid; 5448 spec->auto_adc_cnt++; 5449 } 5450 5451 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid) 5452 { 5453 int i, j; 5454 struct sigmatel_spec *spec = codec->spec; 5455 5456 for (i = 0; i < spec->auto_adc_cnt; i++) { 5457 if (get_connection_index(codec, 5458 spec->auto_adc_nids[i], nid) >= 0) { 5459 /* mux and volume for adc_nids[i] */ 5460 if (!spec->auto_mux_nids[i]) { 5461 spec->auto_mux_nids[i] = nid; 5462 /* 92hd codecs capture volume is in mux */ 5463 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid, 5464 3, 0, HDA_OUTPUT); 5465 } 5466 for (j = 0; j < spec->auto_dmic_cnt; j++) { 5467 if (get_connection_index(codec, nid, 5468 spec->auto_dmic_nids[j]) >= 0) { 5469 /* dmux for adc_nids[i] */ 5470 if (!spec->auto_dmux_nids[i]) 5471 spec->auto_dmux_nids[i] = nid; 5472 break; 5473 } 5474 } 5475 break; 5476 } 5477 } 5478 } 5479 5480 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec) 5481 { 5482 hda_nid_t nid, end_nid; 5483 unsigned int wid_caps, wid_type; 5484 struct sigmatel_spec *spec = codec->spec; 5485 5486 end_nid = codec->start_nid + codec->num_nodes; 5487 5488 for (nid = codec->start_nid; nid < end_nid; nid++) { 5489 wid_caps = get_wcaps(codec, nid); 5490 wid_type = get_wcaps_type(wid_caps); 5491 5492 if (wid_type == AC_WID_PIN) 5493 stac92hd8x_add_pin(codec, nid); 5494 5495 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL)) 5496 stac92hd8x_add_adc(codec, nid); 5497 } 5498 5499 for (nid = codec->start_nid; nid < end_nid; nid++) { 5500 wid_caps = get_wcaps(codec, nid); 5501 wid_type = get_wcaps_type(wid_caps); 5502 5503 if (wid_type == AC_WID_AUD_SEL) 5504 stac92hd8x_add_mux(codec, nid); 5505 } 5506 5507 spec->pin_nids = spec->auto_pin_nids; 5508 spec->num_pins = spec->auto_pin_cnt; 5509 spec->adc_nids = spec->auto_adc_nids; 5510 spec->num_adcs = spec->auto_adc_cnt; 5511 spec->capvols = spec->auto_capvols; 5512 spec->capsws = spec->auto_capvols; 5513 spec->num_caps = spec->auto_adc_cnt; 5514 spec->mux_nids = spec->auto_mux_nids; 5515 spec->num_muxes = spec->auto_adc_cnt; 5516 spec->dmux_nids = spec->auto_dmux_nids; 5517 spec->num_dmuxes = spec->auto_adc_cnt; 5518 spec->dmic_nids = spec->auto_dmic_nids; 5519 spec->num_dmics = spec->auto_dmic_cnt; 5520 } 5521 5522 static int patch_stac92hd83xxx(struct hda_codec *codec) 5523 { 5524 struct sigmatel_spec *spec; 5525 int default_polarity = -1; /* no default cfg */ 5526 int err; 5527 5528 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5529 if (spec == NULL) 5530 return -ENOMEM; 5531 5532 if (hp_bnb2011_with_dock(codec)) { 5533 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f); 5534 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e); 5535 } 5536 5537 codec->epss = 0; /* longer delay needed for D3 */ 5538 codec->no_trigger_sense = 1; 5539 codec->spec = spec; 5540 5541 stac92hd8x_fill_auto_spec(codec); 5542 5543 spec->linear_tone_beep = 0; 5544 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs; 5545 spec->digbeep_nid = 0x21; 5546 spec->pwr_nids = stac92hd83xxx_pwr_nids; 5547 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids); 5548 spec->multiout.dac_nids = spec->dac_nids; 5549 spec->init = stac92hd83xxx_core_init; 5550 5551 spec->board_config = snd_hda_check_board_config(codec, 5552 STAC_92HD83XXX_MODELS, 5553 stac92hd83xxx_models, 5554 stac92hd83xxx_cfg_tbl); 5555 /* check codec subsystem id if not found */ 5556 if (spec->board_config < 0) 5557 spec->board_config = 5558 snd_hda_check_board_codec_sid_config(codec, 5559 STAC_92HD83XXX_MODELS, stac92hd83xxx_models, 5560 stac92hd83xxx_codec_id_cfg_tbl); 5561 again: 5562 if (spec->board_config < 0) 5563 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5564 codec->chip_name); 5565 else 5566 stac92xx_set_config_regs(codec, 5567 stac92hd83xxx_brd_tbl[spec->board_config]); 5568 5569 codec->patch_ops = stac92xx_patch_ops; 5570 5571 switch (spec->board_config) { 5572 case STAC_HP_ZEPHYR: 5573 spec->init = stac92hd83xxx_hp_zephyr_init; 5574 break; 5575 case STAC_92HD83XXX_HP_LED: 5576 default_polarity = 0; 5577 break; 5578 case STAC_92HD83XXX_HP_INV_LED: 5579 default_polarity = 1; 5580 break; 5581 } 5582 5583 if (find_mute_led_cfg(codec, default_polarity)) 5584 snd_printd("mute LED gpio %d polarity %d\n", 5585 spec->gpio_led, 5586 spec->gpio_led_polarity); 5587 5588 if (spec->gpio_led) { 5589 if (!spec->vref_mute_led_nid) { 5590 spec->gpio_mask |= spec->gpio_led; 5591 spec->gpio_dir |= spec->gpio_led; 5592 spec->gpio_data |= spec->gpio_led; 5593 } else { 5594 codec->patch_ops.set_power_state = 5595 stac92xx_set_power_state; 5596 } 5597 } 5598 5599 err = stac92xx_parse_auto_config(codec); 5600 if (!err) { 5601 if (spec->board_config < 0) { 5602 printk(KERN_WARNING "hda_codec: No auto-config is " 5603 "available, default to model=ref\n"); 5604 spec->board_config = STAC_92HD83XXX_REF; 5605 goto again; 5606 } 5607 err = -EINVAL; 5608 } 5609 5610 if (err < 0) { 5611 stac92xx_free(codec); 5612 return err; 5613 } 5614 5615 codec->proc_widget_hook = stac92hd_proc_hook; 5616 5617 return 0; 5618 } 5619 5620 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec, 5621 hda_nid_t dig0pin) 5622 { 5623 struct sigmatel_spec *spec = codec->spec; 5624 int idx; 5625 5626 for (idx = 0; idx < spec->num_pins; idx++) 5627 if (spec->pin_nids[idx] == dig0pin) 5628 break; 5629 if ((idx + 2) >= spec->num_pins) 5630 return 0; 5631 5632 /* dig1pin case */ 5633 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE) 5634 return 2; 5635 5636 /* dig0pin + dig2pin case */ 5637 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE) 5638 return 2; 5639 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE) 5640 return 1; 5641 else 5642 return 0; 5643 } 5644 5645 /* HP dv7 bass switch - GPIO5 */ 5646 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info 5647 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol, 5648 struct snd_ctl_elem_value *ucontrol) 5649 { 5650 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5651 struct sigmatel_spec *spec = codec->spec; 5652 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20); 5653 return 0; 5654 } 5655 5656 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol, 5657 struct snd_ctl_elem_value *ucontrol) 5658 { 5659 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5660 struct sigmatel_spec *spec = codec->spec; 5661 unsigned int gpio_data; 5662 5663 gpio_data = (spec->gpio_data & ~0x20) | 5664 (ucontrol->value.integer.value[0] ? 0x20 : 0); 5665 if (gpio_data == spec->gpio_data) 5666 return 0; 5667 spec->gpio_data = gpio_data; 5668 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data); 5669 return 1; 5670 } 5671 5672 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = { 5673 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5674 .info = stac_hp_bass_gpio_info, 5675 .get = stac_hp_bass_gpio_get, 5676 .put = stac_hp_bass_gpio_put, 5677 }; 5678 5679 static int stac_add_hp_bass_switch(struct hda_codec *codec) 5680 { 5681 struct sigmatel_spec *spec = codec->spec; 5682 5683 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl, 5684 "Bass Speaker Playback Switch", 0)) 5685 return -ENOMEM; 5686 5687 spec->gpio_mask |= 0x20; 5688 spec->gpio_dir |= 0x20; 5689 spec->gpio_data |= 0x20; 5690 return 0; 5691 } 5692 5693 static int patch_stac92hd71bxx(struct hda_codec *codec) 5694 { 5695 struct sigmatel_spec *spec; 5696 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init; 5697 unsigned int pin_cfg; 5698 int err = 0; 5699 5700 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5701 if (spec == NULL) 5702 return -ENOMEM; 5703 5704 codec->no_trigger_sense = 1; 5705 codec->spec = spec; 5706 spec->linear_tone_beep = 0; 5707 codec->patch_ops = stac92xx_patch_ops; 5708 spec->num_pins = STAC92HD71BXX_NUM_PINS; 5709 switch (codec->vendor_id) { 5710 case 0x111d76b6: 5711 case 0x111d76b7: 5712 spec->pin_nids = stac92hd71bxx_pin_nids_4port; 5713 break; 5714 case 0x111d7603: 5715 case 0x111d7608: 5716 /* On 92HD75Bx 0x27 isn't a pin nid */ 5717 spec->num_pins--; 5718 /* fallthrough */ 5719 default: 5720 spec->pin_nids = stac92hd71bxx_pin_nids_6port; 5721 } 5722 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids); 5723 spec->board_config = snd_hda_check_board_config(codec, 5724 STAC_92HD71BXX_MODELS, 5725 stac92hd71bxx_models, 5726 stac92hd71bxx_cfg_tbl); 5727 again: 5728 if (spec->board_config < 0) 5729 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5730 codec->chip_name); 5731 else 5732 stac92xx_set_config_regs(codec, 5733 stac92hd71bxx_brd_tbl[spec->board_config]); 5734 5735 if (spec->board_config != STAC_92HD71BXX_REF) { 5736 /* GPIO0 = EAPD */ 5737 spec->gpio_mask = 0x01; 5738 spec->gpio_dir = 0x01; 5739 spec->gpio_data = 0x01; 5740 } 5741 5742 spec->dmic_nids = stac92hd71bxx_dmic_nids; 5743 spec->dmux_nids = stac92hd71bxx_dmux_nids; 5744 5745 spec->num_caps = STAC92HD71BXX_NUM_CAPS; 5746 spec->capvols = stac92hd71bxx_capvols; 5747 spec->capsws = stac92hd71bxx_capsws; 5748 5749 switch (codec->vendor_id) { 5750 case 0x111d76b6: /* 4 Port without Analog Mixer */ 5751 case 0x111d76b7: 5752 unmute_init++; 5753 /* fallthru */ 5754 case 0x111d76b4: /* 6 Port without Analog Mixer */ 5755 case 0x111d76b5: 5756 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5757 spec->num_dmics = stac92xx_connected_ports(codec, 5758 stac92hd71bxx_dmic_nids, 5759 STAC92HD71BXX_NUM_DMICS); 5760 break; 5761 case 0x111d7608: /* 5 Port with Analog Mixer */ 5762 switch (spec->board_config) { 5763 case STAC_HP_M4: 5764 /* Enable VREF power saving on GPIO1 detect */ 5765 err = stac_add_event(codec, codec->afg, 5766 STAC_VREF_EVENT, 0x02); 5767 if (err < 0) 5768 return err; 5769 snd_hda_codec_write_cache(codec, codec->afg, 0, 5770 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02); 5771 snd_hda_jack_detect_enable(codec, codec->afg, 0); 5772 spec->gpio_mask |= 0x02; 5773 break; 5774 } 5775 if ((codec->revision_id & 0xf) == 0 || 5776 (codec->revision_id & 0xf) == 1) 5777 spec->stream_delay = 40; /* 40 milliseconds */ 5778 5779 /* disable VSW */ 5780 unmute_init++; 5781 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); 5782 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); 5783 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids; 5784 spec->num_dmics = stac92xx_connected_ports(codec, 5785 stac92hd71bxx_dmic_5port_nids, 5786 STAC92HD71BXX_NUM_DMICS - 1); 5787 break; 5788 case 0x111d7603: /* 6 Port with Analog Mixer */ 5789 if ((codec->revision_id & 0xf) == 1) 5790 spec->stream_delay = 40; /* 40 milliseconds */ 5791 5792 /* fallthru */ 5793 default: 5794 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5795 spec->num_dmics = stac92xx_connected_ports(codec, 5796 stac92hd71bxx_dmic_nids, 5797 STAC92HD71BXX_NUM_DMICS); 5798 break; 5799 } 5800 5801 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB) 5802 spec->init = stac92hd71bxx_core_init; 5803 5804 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) 5805 snd_hda_sequence_write_cache(codec, unmute_init); 5806 5807 spec->aloopback_ctl = stac92hd71bxx_loopback; 5808 spec->aloopback_mask = 0x50; 5809 spec->aloopback_shift = 0; 5810 5811 spec->powerdown_adcs = 1; 5812 spec->digbeep_nid = 0x26; 5813 spec->mux_nids = stac92hd71bxx_mux_nids; 5814 spec->adc_nids = stac92hd71bxx_adc_nids; 5815 spec->smux_nids = stac92hd71bxx_smux_nids; 5816 spec->pwr_nids = stac92hd71bxx_pwr_nids; 5817 5818 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids); 5819 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids); 5820 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids); 5821 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e); 5822 5823 snd_printdd("Found board config: %d\n", spec->board_config); 5824 5825 switch (spec->board_config) { 5826 case STAC_HP_M4: 5827 /* enable internal microphone */ 5828 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040); 5829 stac92xx_auto_set_pinctl(codec, 0x0e, 5830 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80); 5831 /* fallthru */ 5832 case STAC_DELL_M4_2: 5833 spec->num_dmics = 0; 5834 spec->num_smuxes = 0; 5835 spec->num_dmuxes = 0; 5836 break; 5837 case STAC_DELL_M4_1: 5838 case STAC_DELL_M4_3: 5839 spec->num_dmics = 1; 5840 spec->num_smuxes = 0; 5841 spec->num_dmuxes = 1; 5842 break; 5843 case STAC_HP_DV4_1222NR: 5844 spec->num_dmics = 1; 5845 /* I don't know if it needs 1 or 2 smuxes - will wait for 5846 * bug reports to fix if needed 5847 */ 5848 spec->num_smuxes = 1; 5849 spec->num_dmuxes = 1; 5850 /* fallthrough */ 5851 case STAC_HP_DV4: 5852 spec->gpio_led = 0x01; 5853 /* fallthrough */ 5854 case STAC_HP_DV5: 5855 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010); 5856 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN); 5857 /* HP dv6 gives the headphone pin as a line-out. Thus we 5858 * need to set hp_detect flag here to force to enable HP 5859 * detection. 5860 */ 5861 spec->hp_detect = 1; 5862 break; 5863 case STAC_HP_HDX: 5864 spec->num_dmics = 1; 5865 spec->num_dmuxes = 1; 5866 spec->num_smuxes = 1; 5867 spec->gpio_led = 0x08; 5868 break; 5869 } 5870 5871 if (hp_blike_system(codec->subsystem_id)) { 5872 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f); 5873 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT || 5874 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER || 5875 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) { 5876 /* It was changed in the BIOS to just satisfy MS DTM. 5877 * Lets turn it back into slaved HP 5878 */ 5879 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE)) 5880 | (AC_JACK_HP_OUT << 5881 AC_DEFCFG_DEVICE_SHIFT); 5882 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC 5883 | AC_DEFCFG_SEQUENCE))) 5884 | 0x1f; 5885 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg); 5886 } 5887 } 5888 5889 if (find_mute_led_cfg(codec, 1)) 5890 snd_printd("mute LED gpio %d polarity %d\n", 5891 spec->gpio_led, 5892 spec->gpio_led_polarity); 5893 5894 if (spec->gpio_led) { 5895 if (!spec->vref_mute_led_nid) { 5896 spec->gpio_mask |= spec->gpio_led; 5897 spec->gpio_dir |= spec->gpio_led; 5898 spec->gpio_data |= spec->gpio_led; 5899 } else { 5900 codec->patch_ops.set_power_state = 5901 stac92xx_set_power_state; 5902 } 5903 } 5904 5905 spec->multiout.dac_nids = spec->dac_nids; 5906 5907 err = stac92xx_parse_auto_config(codec); 5908 if (!err) { 5909 if (spec->board_config < 0) { 5910 printk(KERN_WARNING "hda_codec: No auto-config is " 5911 "available, default to model=ref\n"); 5912 spec->board_config = STAC_92HD71BXX_REF; 5913 goto again; 5914 } 5915 err = -EINVAL; 5916 } 5917 5918 if (err < 0) { 5919 stac92xx_free(codec); 5920 return err; 5921 } 5922 5923 /* enable bass on HP dv7 */ 5924 if (spec->board_config == STAC_HP_DV4 || 5925 spec->board_config == STAC_HP_DV5) { 5926 unsigned int cap; 5927 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP); 5928 cap &= AC_GPIO_IO_COUNT; 5929 if (cap >= 6) 5930 stac_add_hp_bass_switch(codec); 5931 } 5932 5933 codec->proc_widget_hook = stac92hd7x_proc_hook; 5934 5935 return 0; 5936 } 5937 5938 static int patch_stac922x(struct hda_codec *codec) 5939 { 5940 struct sigmatel_spec *spec; 5941 int err; 5942 5943 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5944 if (spec == NULL) 5945 return -ENOMEM; 5946 5947 codec->no_trigger_sense = 1; 5948 codec->spec = spec; 5949 spec->linear_tone_beep = 1; 5950 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids); 5951 spec->pin_nids = stac922x_pin_nids; 5952 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS, 5953 stac922x_models, 5954 stac922x_cfg_tbl); 5955 if (spec->board_config == STAC_INTEL_MAC_AUTO) { 5956 spec->gpio_mask = spec->gpio_dir = 0x03; 5957 spec->gpio_data = 0x03; 5958 /* Intel Macs have all same PCI SSID, so we need to check 5959 * codec SSID to distinguish the exact models 5960 */ 5961 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id); 5962 switch (codec->subsystem_id) { 5963 5964 case 0x106b0800: 5965 spec->board_config = STAC_INTEL_MAC_V1; 5966 break; 5967 case 0x106b0600: 5968 case 0x106b0700: 5969 spec->board_config = STAC_INTEL_MAC_V2; 5970 break; 5971 case 0x106b0e00: 5972 case 0x106b0f00: 5973 case 0x106b1600: 5974 case 0x106b1700: 5975 case 0x106b0200: 5976 case 0x106b1e00: 5977 spec->board_config = STAC_INTEL_MAC_V3; 5978 break; 5979 case 0x106b1a00: 5980 case 0x00000100: 5981 spec->board_config = STAC_INTEL_MAC_V4; 5982 break; 5983 case 0x106b0a00: 5984 case 0x106b2200: 5985 spec->board_config = STAC_INTEL_MAC_V5; 5986 break; 5987 default: 5988 spec->board_config = STAC_INTEL_MAC_V3; 5989 break; 5990 } 5991 } 5992 5993 again: 5994 if (spec->board_config < 0) 5995 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5996 codec->chip_name); 5997 else 5998 stac92xx_set_config_regs(codec, 5999 stac922x_brd_tbl[spec->board_config]); 6000 6001 spec->adc_nids = stac922x_adc_nids; 6002 spec->mux_nids = stac922x_mux_nids; 6003 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids); 6004 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids); 6005 spec->num_dmics = 0; 6006 spec->num_pwrs = 0; 6007 6008 spec->init = stac922x_core_init; 6009 6010 spec->num_caps = STAC922X_NUM_CAPS; 6011 spec->capvols = stac922x_capvols; 6012 spec->capsws = stac922x_capsws; 6013 6014 spec->multiout.dac_nids = spec->dac_nids; 6015 6016 err = stac92xx_parse_auto_config(codec); 6017 if (!err) { 6018 if (spec->board_config < 0) { 6019 printk(KERN_WARNING "hda_codec: No auto-config is " 6020 "available, default to model=ref\n"); 6021 spec->board_config = STAC_D945_REF; 6022 goto again; 6023 } 6024 err = -EINVAL; 6025 } 6026 if (err < 0) { 6027 stac92xx_free(codec); 6028 return err; 6029 } 6030 6031 codec->patch_ops = stac92xx_patch_ops; 6032 6033 /* Fix Mux capture level; max to 2 */ 6034 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT, 6035 (0 << AC_AMPCAP_OFFSET_SHIFT) | 6036 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6037 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) | 6038 (0 << AC_AMPCAP_MUTE_SHIFT)); 6039 6040 return 0; 6041 } 6042 6043 static int patch_stac927x(struct hda_codec *codec) 6044 { 6045 struct sigmatel_spec *spec; 6046 int err; 6047 6048 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6049 if (spec == NULL) 6050 return -ENOMEM; 6051 6052 codec->no_trigger_sense = 1; 6053 codec->spec = spec; 6054 spec->linear_tone_beep = 1; 6055 codec->slave_dig_outs = stac927x_slave_dig_outs; 6056 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids); 6057 spec->pin_nids = stac927x_pin_nids; 6058 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS, 6059 stac927x_models, 6060 stac927x_cfg_tbl); 6061 again: 6062 if (spec->board_config < 0) 6063 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6064 codec->chip_name); 6065 else 6066 stac92xx_set_config_regs(codec, 6067 stac927x_brd_tbl[spec->board_config]); 6068 6069 spec->digbeep_nid = 0x23; 6070 spec->adc_nids = stac927x_adc_nids; 6071 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids); 6072 spec->mux_nids = stac927x_mux_nids; 6073 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids); 6074 spec->smux_nids = stac927x_smux_nids; 6075 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids); 6076 spec->spdif_labels = stac927x_spdif_labels; 6077 spec->dac_list = stac927x_dac_nids; 6078 spec->multiout.dac_nids = spec->dac_nids; 6079 6080 if (spec->board_config != STAC_D965_REF) { 6081 /* GPIO0 High = Enable EAPD */ 6082 spec->eapd_mask = spec->gpio_mask = 0x01; 6083 spec->gpio_dir = spec->gpio_data = 0x01; 6084 } 6085 6086 switch (spec->board_config) { 6087 case STAC_D965_3ST: 6088 case STAC_D965_5ST: 6089 /* GPIO0 High = Enable EAPD */ 6090 spec->num_dmics = 0; 6091 spec->init = d965_core_init; 6092 break; 6093 case STAC_DELL_BIOS: 6094 switch (codec->subsystem_id) { 6095 case 0x10280209: 6096 case 0x1028022e: 6097 /* correct the device field to SPDIF out */ 6098 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070); 6099 break; 6100 } 6101 /* configure the analog microphone on some laptops */ 6102 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130); 6103 /* correct the front output jack as a hp out */ 6104 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f); 6105 /* correct the front input jack as a mic */ 6106 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130); 6107 /* fallthru */ 6108 case STAC_DELL_3ST: 6109 if (codec->subsystem_id != 0x1028022f) { 6110 /* GPIO2 High = Enable EAPD */ 6111 spec->eapd_mask = spec->gpio_mask = 0x04; 6112 spec->gpio_dir = spec->gpio_data = 0x04; 6113 } 6114 spec->dmic_nids = stac927x_dmic_nids; 6115 spec->num_dmics = STAC927X_NUM_DMICS; 6116 6117 spec->init = dell_3st_core_init; 6118 spec->dmux_nids = stac927x_dmux_nids; 6119 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids); 6120 break; 6121 case STAC_927X_VOLKNOB: 6122 spec->num_dmics = 0; 6123 spec->init = stac927x_volknob_core_init; 6124 break; 6125 default: 6126 spec->num_dmics = 0; 6127 spec->init = stac927x_core_init; 6128 break; 6129 } 6130 6131 spec->num_caps = STAC927X_NUM_CAPS; 6132 spec->capvols = stac927x_capvols; 6133 spec->capsws = stac927x_capsws; 6134 6135 spec->num_pwrs = 0; 6136 spec->aloopback_ctl = stac927x_loopback; 6137 spec->aloopback_mask = 0x40; 6138 spec->aloopback_shift = 0; 6139 spec->eapd_switch = 1; 6140 6141 err = stac92xx_parse_auto_config(codec); 6142 if (!err) { 6143 if (spec->board_config < 0) { 6144 printk(KERN_WARNING "hda_codec: No auto-config is " 6145 "available, default to model=ref\n"); 6146 spec->board_config = STAC_D965_REF; 6147 goto again; 6148 } 6149 err = -EINVAL; 6150 } 6151 if (err < 0) { 6152 stac92xx_free(codec); 6153 return err; 6154 } 6155 6156 codec->patch_ops = stac92xx_patch_ops; 6157 6158 codec->proc_widget_hook = stac927x_proc_hook; 6159 6160 /* 6161 * !!FIXME!! 6162 * The STAC927x seem to require fairly long delays for certain 6163 * command sequences. With too short delays (even if the answer 6164 * is set to RIRB properly), it results in the silence output 6165 * on some hardwares like Dell. 6166 * 6167 * The below flag enables the longer delay (see get_response 6168 * in hda_intel.c). 6169 */ 6170 codec->bus->needs_damn_long_delay = 1; 6171 6172 /* no jack detecion for ref-no-jd model */ 6173 if (spec->board_config == STAC_D965_REF_NO_JD) 6174 spec->hp_detect = 0; 6175 6176 return 0; 6177 } 6178 6179 static int patch_stac9205(struct hda_codec *codec) 6180 { 6181 struct sigmatel_spec *spec; 6182 int err; 6183 6184 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6185 if (spec == NULL) 6186 return -ENOMEM; 6187 6188 codec->no_trigger_sense = 1; 6189 codec->spec = spec; 6190 spec->linear_tone_beep = 1; 6191 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids); 6192 spec->pin_nids = stac9205_pin_nids; 6193 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS, 6194 stac9205_models, 6195 stac9205_cfg_tbl); 6196 again: 6197 if (spec->board_config < 0) 6198 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6199 codec->chip_name); 6200 else 6201 stac92xx_set_config_regs(codec, 6202 stac9205_brd_tbl[spec->board_config]); 6203 6204 spec->digbeep_nid = 0x23; 6205 spec->adc_nids = stac9205_adc_nids; 6206 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids); 6207 spec->mux_nids = stac9205_mux_nids; 6208 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids); 6209 spec->smux_nids = stac9205_smux_nids; 6210 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids); 6211 spec->dmic_nids = stac9205_dmic_nids; 6212 spec->num_dmics = STAC9205_NUM_DMICS; 6213 spec->dmux_nids = stac9205_dmux_nids; 6214 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids); 6215 spec->num_pwrs = 0; 6216 6217 spec->init = stac9205_core_init; 6218 spec->aloopback_ctl = stac9205_loopback; 6219 6220 spec->num_caps = STAC9205_NUM_CAPS; 6221 spec->capvols = stac9205_capvols; 6222 spec->capsws = stac9205_capsws; 6223 6224 spec->aloopback_mask = 0x40; 6225 spec->aloopback_shift = 0; 6226 /* Turn on/off EAPD per HP plugging */ 6227 if (spec->board_config != STAC_9205_EAPD) 6228 spec->eapd_switch = 1; 6229 spec->multiout.dac_nids = spec->dac_nids; 6230 6231 switch (spec->board_config){ 6232 case STAC_9205_DELL_M43: 6233 /* Enable SPDIF in/out */ 6234 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030); 6235 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030); 6236 6237 /* Enable unsol response for GPIO4/Dock HP connection */ 6238 err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01); 6239 if (err < 0) 6240 return err; 6241 snd_hda_codec_write_cache(codec, codec->afg, 0, 6242 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10); 6243 snd_hda_jack_detect_enable(codec, codec->afg, 0); 6244 6245 spec->gpio_dir = 0x0b; 6246 spec->eapd_mask = 0x01; 6247 spec->gpio_mask = 0x1b; 6248 spec->gpio_mute = 0x10; 6249 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute, 6250 * GPIO3 Low = DRM 6251 */ 6252 spec->gpio_data = 0x01; 6253 break; 6254 case STAC_9205_REF: 6255 /* SPDIF-In enabled */ 6256 break; 6257 default: 6258 /* GPIO0 High = EAPD */ 6259 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 6260 spec->gpio_data = 0x01; 6261 break; 6262 } 6263 6264 err = stac92xx_parse_auto_config(codec); 6265 if (!err) { 6266 if (spec->board_config < 0) { 6267 printk(KERN_WARNING "hda_codec: No auto-config is " 6268 "available, default to model=ref\n"); 6269 spec->board_config = STAC_9205_REF; 6270 goto again; 6271 } 6272 err = -EINVAL; 6273 } 6274 if (err < 0) { 6275 stac92xx_free(codec); 6276 return err; 6277 } 6278 6279 codec->patch_ops = stac92xx_patch_ops; 6280 6281 codec->proc_widget_hook = stac9205_proc_hook; 6282 6283 return 0; 6284 } 6285 6286 /* 6287 * STAC9872 hack 6288 */ 6289 6290 static const struct hda_verb stac9872_core_init[] = { 6291 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */ 6292 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */ 6293 {} 6294 }; 6295 6296 static const hda_nid_t stac9872_pin_nids[] = { 6297 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 6298 0x11, 0x13, 0x14, 6299 }; 6300 6301 static const hda_nid_t stac9872_adc_nids[] = { 6302 0x8 /*,0x6*/ 6303 }; 6304 6305 static const hda_nid_t stac9872_mux_nids[] = { 6306 0x15 6307 }; 6308 6309 static const unsigned long stac9872_capvols[] = { 6310 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 6311 }; 6312 #define stac9872_capsws stac9872_capvols 6313 6314 static const unsigned int stac9872_vaio_pin_configs[9] = { 6315 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030, 6316 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0, 6317 0x90a7013e 6318 }; 6319 6320 static const char * const stac9872_models[STAC_9872_MODELS] = { 6321 [STAC_9872_AUTO] = "auto", 6322 [STAC_9872_VAIO] = "vaio", 6323 }; 6324 6325 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = { 6326 [STAC_9872_VAIO] = stac9872_vaio_pin_configs, 6327 }; 6328 6329 static const struct snd_pci_quirk stac9872_cfg_tbl[] = { 6330 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0, 6331 "Sony VAIO F/S", STAC_9872_VAIO), 6332 {} /* terminator */ 6333 }; 6334 6335 static int patch_stac9872(struct hda_codec *codec) 6336 { 6337 struct sigmatel_spec *spec; 6338 int err; 6339 6340 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6341 if (spec == NULL) 6342 return -ENOMEM; 6343 codec->no_trigger_sense = 1; 6344 codec->spec = spec; 6345 spec->linear_tone_beep = 1; 6346 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids); 6347 spec->pin_nids = stac9872_pin_nids; 6348 6349 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS, 6350 stac9872_models, 6351 stac9872_cfg_tbl); 6352 if (spec->board_config < 0) 6353 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6354 codec->chip_name); 6355 else 6356 stac92xx_set_config_regs(codec, 6357 stac9872_brd_tbl[spec->board_config]); 6358 6359 spec->multiout.dac_nids = spec->dac_nids; 6360 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids); 6361 spec->adc_nids = stac9872_adc_nids; 6362 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids); 6363 spec->mux_nids = stac9872_mux_nids; 6364 spec->init = stac9872_core_init; 6365 spec->num_caps = 1; 6366 spec->capvols = stac9872_capvols; 6367 spec->capsws = stac9872_capsws; 6368 6369 err = stac92xx_parse_auto_config(codec); 6370 if (err < 0) { 6371 stac92xx_free(codec); 6372 return -EINVAL; 6373 } 6374 spec->input_mux = &spec->private_imux; 6375 codec->patch_ops = stac92xx_patch_ops; 6376 return 0; 6377 } 6378 6379 6380 /* 6381 * patch entries 6382 */ 6383 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = { 6384 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 }, 6385 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x }, 6386 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x }, 6387 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x }, 6388 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x }, 6389 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x }, 6390 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x }, 6391 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x }, 6392 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x }, 6393 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x }, 6394 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x }, 6395 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x }, 6396 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x }, 6397 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x }, 6398 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x }, 6399 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x }, 6400 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x }, 6401 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x }, 6402 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x }, 6403 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x }, 6404 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x }, 6405 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x }, 6406 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x }, 6407 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x }, 6408 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x }, 6409 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x }, 6410 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x }, 6411 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x }, 6412 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x }, 6413 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x }, 6414 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x }, 6415 /* The following does not take into account .id=0x83847661 when subsys = 6416 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are 6417 * currently not fully supported. 6418 */ 6419 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 }, 6420 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 }, 6421 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 }, 6422 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 }, 6423 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 }, 6424 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 }, 6425 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 }, 6426 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 }, 6427 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 }, 6428 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 }, 6429 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 }, 6430 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 }, 6431 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx}, 6432 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx}, 6433 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx}, 6434 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx}, 6435 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx}, 6436 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx}, 6437 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx}, 6438 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx}, 6439 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx}, 6440 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx}, 6441 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx}, 6442 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx}, 6443 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx }, 6444 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx }, 6445 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx }, 6446 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6447 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6448 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6449 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6450 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6451 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6452 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6453 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6454 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx }, 6455 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx }, 6456 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx }, 6457 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx }, 6458 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx }, 6459 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx }, 6460 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx }, 6461 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx }, 6462 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx }, 6463 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx }, 6464 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx }, 6465 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx }, 6466 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx }, 6467 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx }, 6468 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx }, 6469 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx}, 6470 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx}, 6471 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx}, 6472 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx}, 6473 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx}, 6474 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx}, 6475 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx}, 6476 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx}, 6477 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx}, 6478 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx}, 6479 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx}, 6480 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx}, 6481 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx}, 6482 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx}, 6483 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx}, 6484 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx}, 6485 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx}, 6486 {} /* terminator */ 6487 }; 6488 6489 MODULE_ALIAS("snd-hda-codec-id:8384*"); 6490 MODULE_ALIAS("snd-hda-codec-id:111d*"); 6491 6492 MODULE_LICENSE("GPL"); 6493 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec"); 6494 6495 static struct hda_codec_preset_list sigmatel_list = { 6496 .preset = snd_hda_preset_sigmatel, 6497 .owner = THIS_MODULE, 6498 }; 6499 6500 static int __init patch_sigmatel_init(void) 6501 { 6502 return snd_hda_add_codec_preset(&sigmatel_list); 6503 } 6504 6505 static void __exit patch_sigmatel_exit(void) 6506 { 6507 snd_hda_delete_codec_preset(&sigmatel_list); 6508 } 6509 6510 module_init(patch_sigmatel_init) 6511 module_exit(patch_sigmatel_exit) 6512