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 for (i = 0; i < cfg->line_outs; i++) { 4547 if (presence) 4548 break; 4549 presence = get_pin_presence(codec, cfg->line_out_pins[i]); 4550 if (presence) { 4551 unsigned int pinctl; 4552 pinctl = snd_hda_codec_read(codec, 4553 cfg->line_out_pins[i], 0, 4554 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4555 if (pinctl & AC_PINCTL_IN_EN) 4556 presence = 0; /* mic- or line-input */ 4557 } 4558 } 4559 4560 if (presence) { 4561 /* disable speakers */ 4562 for (i = 0; i < cfg->speaker_outs; i++) 4563 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i], 4564 AC_PINCTL_OUT_EN); 4565 if (spec->eapd_mask && spec->eapd_switch) 4566 stac_gpio_set(codec, spec->gpio_mask, 4567 spec->gpio_dir, spec->gpio_data & 4568 ~spec->eapd_mask); 4569 } else { 4570 /* enable speakers */ 4571 for (i = 0; i < cfg->speaker_outs; i++) 4572 stac92xx_set_pinctl(codec, cfg->speaker_pins[i], 4573 AC_PINCTL_OUT_EN); 4574 if (spec->eapd_mask && spec->eapd_switch) 4575 stac_gpio_set(codec, spec->gpio_mask, 4576 spec->gpio_dir, spec->gpio_data | 4577 spec->eapd_mask); 4578 } 4579 } 4580 4581 /* return non-zero if the hp-pin of the given array index isn't 4582 * a jack-detection target 4583 */ 4584 static int no_hp_sensing(struct sigmatel_spec *spec, int i) 4585 { 4586 struct auto_pin_cfg *cfg = &spec->autocfg; 4587 4588 /* ignore sensing of shared line and mic jacks */ 4589 if (cfg->hp_pins[i] == spec->line_switch) 4590 return 1; 4591 if (cfg->hp_pins[i] == spec->mic_switch) 4592 return 1; 4593 /* ignore if the pin is set as line-out */ 4594 if (cfg->hp_pins[i] == spec->hp_switch) 4595 return 1; 4596 return 0; 4597 } 4598 4599 static void stac92xx_hp_detect(struct hda_codec *codec) 4600 { 4601 struct sigmatel_spec *spec = codec->spec; 4602 struct auto_pin_cfg *cfg = &spec->autocfg; 4603 int i, presence; 4604 4605 presence = 0; 4606 if (spec->gpio_mute) 4607 presence = !(snd_hda_codec_read(codec, codec->afg, 0, 4608 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute); 4609 4610 for (i = 0; i < cfg->hp_outs; i++) { 4611 if (presence) 4612 break; 4613 if (no_hp_sensing(spec, i)) 4614 continue; 4615 presence = get_pin_presence(codec, cfg->hp_pins[i]); 4616 if (presence) { 4617 unsigned int pinctl; 4618 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0, 4619 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4620 if (pinctl & AC_PINCTL_IN_EN) 4621 presence = 0; /* mic- or line-input */ 4622 } 4623 } 4624 4625 if (presence) { 4626 /* disable lineouts */ 4627 if (spec->hp_switch) 4628 stac92xx_reset_pinctl(codec, spec->hp_switch, 4629 AC_PINCTL_OUT_EN); 4630 for (i = 0; i < cfg->line_outs; i++) 4631 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i], 4632 AC_PINCTL_OUT_EN); 4633 } else { 4634 /* enable lineouts */ 4635 if (spec->hp_switch) 4636 stac92xx_set_pinctl(codec, spec->hp_switch, 4637 AC_PINCTL_OUT_EN); 4638 for (i = 0; i < cfg->line_outs; i++) 4639 stac92xx_set_pinctl(codec, cfg->line_out_pins[i], 4640 AC_PINCTL_OUT_EN); 4641 } 4642 stac92xx_line_out_detect(codec, presence); 4643 /* toggle hp outs */ 4644 for (i = 0; i < cfg->hp_outs; i++) { 4645 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN; 4646 if (no_hp_sensing(spec, i)) 4647 continue; 4648 if (1 /*presence*/) 4649 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val); 4650 #if 0 /* FIXME */ 4651 /* Resetting the pinctl like below may lead to (a sort of) regressions 4652 * on some devices since they use the HP pin actually for line/speaker 4653 * outs although the default pin config shows a different pin (that is 4654 * wrong and useless). 4655 * 4656 * So, it's basically a problem of default pin configs, likely a BIOS issue. 4657 * But, disabling the code below just works around it, and I'm too tired of 4658 * bug reports with such devices... 4659 */ 4660 else 4661 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val); 4662 #endif /* FIXME */ 4663 } 4664 } 4665 4666 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid, 4667 int enable) 4668 { 4669 struct sigmatel_spec *spec = codec->spec; 4670 unsigned int idx, val; 4671 4672 for (idx = 0; idx < spec->num_pwrs; idx++) { 4673 if (spec->pwr_nids[idx] == nid) 4674 break; 4675 } 4676 if (idx >= spec->num_pwrs) 4677 return; 4678 4679 idx = 1 << idx; 4680 4681 val = spec->power_map_bits; 4682 if (enable) 4683 val &= ~idx; 4684 else 4685 val |= idx; 4686 4687 /* power down unused output ports */ 4688 if (val != spec->power_map_bits) { 4689 spec->power_map_bits = val; 4690 snd_hda_codec_write(codec, codec->afg, 0, 4691 AC_VERB_IDT_SET_POWER_MAP, val); 4692 } 4693 } 4694 4695 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid) 4696 { 4697 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid)); 4698 } 4699 4700 /* get the pin connection (fixed, none, etc) */ 4701 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx) 4702 { 4703 struct sigmatel_spec *spec = codec->spec; 4704 unsigned int cfg; 4705 4706 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]); 4707 return get_defcfg_connect(cfg); 4708 } 4709 4710 static int stac92xx_connected_ports(struct hda_codec *codec, 4711 const hda_nid_t *nids, int num_nids) 4712 { 4713 struct sigmatel_spec *spec = codec->spec; 4714 int idx, num; 4715 unsigned int def_conf; 4716 4717 for (num = 0; num < num_nids; num++) { 4718 for (idx = 0; idx < spec->num_pins; idx++) 4719 if (spec->pin_nids[idx] == nids[num]) 4720 break; 4721 if (idx >= spec->num_pins) 4722 break; 4723 def_conf = stac_get_defcfg_connect(codec, idx); 4724 if (def_conf == AC_JACK_PORT_NONE) 4725 break; 4726 } 4727 return num; 4728 } 4729 4730 static void stac92xx_mic_detect(struct hda_codec *codec) 4731 { 4732 struct sigmatel_spec *spec = codec->spec; 4733 struct sigmatel_mic_route *mic; 4734 4735 if (get_pin_presence(codec, spec->ext_mic.pin)) 4736 mic = &spec->ext_mic; 4737 else if (get_pin_presence(codec, spec->dock_mic.pin)) 4738 mic = &spec->dock_mic; 4739 else 4740 mic = &spec->int_mic; 4741 if (mic->dmux_idx >= 0) 4742 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0, 4743 AC_VERB_SET_CONNECT_SEL, 4744 mic->dmux_idx); 4745 if (mic->mux_idx >= 0) 4746 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0, 4747 AC_VERB_SET_CONNECT_SEL, 4748 mic->mux_idx); 4749 } 4750 4751 static void handle_unsol_event(struct hda_codec *codec, 4752 struct hda_jack_tbl *event) 4753 { 4754 struct sigmatel_spec *spec = codec->spec; 4755 int data; 4756 4757 switch (event->action) { 4758 case STAC_HP_EVENT: 4759 case STAC_LO_EVENT: 4760 stac92xx_hp_detect(codec); 4761 break; 4762 case STAC_MIC_EVENT: 4763 stac92xx_mic_detect(codec); 4764 break; 4765 } 4766 4767 switch (event->action) { 4768 case STAC_HP_EVENT: 4769 case STAC_LO_EVENT: 4770 case STAC_MIC_EVENT: 4771 case STAC_INSERT_EVENT: 4772 case STAC_PWR_EVENT: 4773 if (spec->num_pwrs > 0) 4774 stac92xx_pin_sense(codec, event->nid); 4775 4776 switch (codec->subsystem_id) { 4777 case 0x103c308f: 4778 if (event->nid == 0xb) { 4779 int pin = AC_PINCTL_IN_EN; 4780 4781 if (get_pin_presence(codec, 0xa) 4782 && get_pin_presence(codec, 0xb)) 4783 pin |= AC_PINCTL_VREF_80; 4784 if (!get_pin_presence(codec, 0xb)) 4785 pin |= AC_PINCTL_VREF_80; 4786 4787 /* toggle VREF state based on mic + hp pin 4788 * status 4789 */ 4790 stac92xx_auto_set_pinctl(codec, 0x0a, pin); 4791 } 4792 } 4793 break; 4794 case STAC_VREF_EVENT: 4795 data = snd_hda_codec_read(codec, codec->afg, 0, 4796 AC_VERB_GET_GPIO_DATA, 0); 4797 /* toggle VREF state based on GPIOx status */ 4798 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0, 4799 !!(data & (1 << event->private_data))); 4800 break; 4801 } 4802 } 4803 4804 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid) 4805 { 4806 struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid); 4807 if (!event) 4808 return; 4809 handle_unsol_event(codec, event); 4810 } 4811 4812 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res) 4813 { 4814 struct hda_jack_tbl *event; 4815 int tag; 4816 4817 tag = (res >> 26) & 0x7f; 4818 event = snd_hda_jack_tbl_get_from_tag(codec, tag); 4819 if (!event) 4820 return; 4821 event->jack_dirty = 1; 4822 handle_unsol_event(codec, event); 4823 snd_hda_jack_report_sync(codec); 4824 } 4825 4826 static int hp_blike_system(u32 subsystem_id); 4827 4828 static void set_hp_led_gpio(struct hda_codec *codec) 4829 { 4830 struct sigmatel_spec *spec = codec->spec; 4831 unsigned int gpio; 4832 4833 if (spec->gpio_led) 4834 return; 4835 4836 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP); 4837 gpio &= AC_GPIO_IO_COUNT; 4838 if (gpio > 3) 4839 spec->gpio_led = 0x08; /* GPIO 3 */ 4840 else 4841 spec->gpio_led = 0x01; /* GPIO 0 */ 4842 } 4843 4844 /* 4845 * This method searches for the mute LED GPIO configuration 4846 * provided as OEM string in SMBIOS. The format of that string 4847 * is HP_Mute_LED_P_G or HP_Mute_LED_P 4848 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high) 4849 * that corresponds to the NOT muted state of the master volume 4850 * and G is the index of the GPIO to use as the mute LED control (0..9) 4851 * If _G portion is missing it is assigned based on the codec ID 4852 * 4853 * So, HP B-series like systems may have HP_Mute_LED_0 (current models) 4854 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings 4855 * 4856 * 4857 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in 4858 * SMBIOS - at least the ones I have seen do not have them - which include 4859 * my own system (HP Pavilion dv6-1110ax) and my cousin's 4860 * HP Pavilion dv9500t CTO. 4861 * Need more information on whether it is true across the entire series. 4862 * -- kunal 4863 */ 4864 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity) 4865 { 4866 struct sigmatel_spec *spec = codec->spec; 4867 const struct dmi_device *dev = NULL; 4868 4869 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) { 4870 get_int_hint(codec, "gpio_led_polarity", 4871 &spec->gpio_led_polarity); 4872 return 1; 4873 } 4874 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) { 4875 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, 4876 NULL, dev))) { 4877 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", 4878 &spec->gpio_led_polarity, 4879 &spec->gpio_led) == 2) { 4880 unsigned int max_gpio; 4881 max_gpio = snd_hda_param_read(codec, codec->afg, 4882 AC_PAR_GPIO_CAP); 4883 max_gpio &= AC_GPIO_IO_COUNT; 4884 if (spec->gpio_led < max_gpio) 4885 spec->gpio_led = 1 << spec->gpio_led; 4886 else 4887 spec->vref_mute_led_nid = spec->gpio_led; 4888 return 1; 4889 } 4890 if (sscanf(dev->name, "HP_Mute_LED_%d", 4891 &spec->gpio_led_polarity) == 1) { 4892 set_hp_led_gpio(codec); 4893 return 1; 4894 } 4895 /* BIOS bug: unfilled OEM string */ 4896 if (strstr(dev->name, "HP_Mute_LED_P_G")) { 4897 set_hp_led_gpio(codec); 4898 switch (codec->subsystem_id) { 4899 case 0x103c148a: 4900 spec->gpio_led_polarity = 0; 4901 break; 4902 default: 4903 spec->gpio_led_polarity = 1; 4904 break; 4905 } 4906 return 1; 4907 } 4908 } 4909 4910 /* 4911 * Fallback case - if we don't find the DMI strings, 4912 * we statically set the GPIO - if not a B-series system 4913 * and default polarity is provided 4914 */ 4915 if (!hp_blike_system(codec->subsystem_id) && 4916 (default_polarity == 0 || default_polarity == 1)) { 4917 set_hp_led_gpio(codec); 4918 spec->gpio_led_polarity = default_polarity; 4919 return 1; 4920 } 4921 } 4922 return 0; 4923 } 4924 4925 static int hp_blike_system(u32 subsystem_id) 4926 { 4927 switch (subsystem_id) { 4928 case 0x103c1520: 4929 case 0x103c1521: 4930 case 0x103c1523: 4931 case 0x103c1524: 4932 case 0x103c1525: 4933 case 0x103c1722: 4934 case 0x103c1723: 4935 case 0x103c1724: 4936 case 0x103c1725: 4937 case 0x103c1726: 4938 case 0x103c1727: 4939 case 0x103c1728: 4940 case 0x103c1729: 4941 case 0x103c172a: 4942 case 0x103c172b: 4943 case 0x103c307e: 4944 case 0x103c307f: 4945 case 0x103c3080: 4946 case 0x103c3081: 4947 case 0x103c7007: 4948 case 0x103c7008: 4949 return 1; 4950 } 4951 return 0; 4952 } 4953 4954 #ifdef CONFIG_PROC_FS 4955 static void stac92hd_proc_hook(struct snd_info_buffer *buffer, 4956 struct hda_codec *codec, hda_nid_t nid) 4957 { 4958 if (nid == codec->afg) 4959 snd_iprintf(buffer, "Power-Map: 0x%02x\n", 4960 snd_hda_codec_read(codec, nid, 0, 4961 AC_VERB_IDT_GET_POWER_MAP, 0)); 4962 } 4963 4964 static void analog_loop_proc_hook(struct snd_info_buffer *buffer, 4965 struct hda_codec *codec, 4966 unsigned int verb) 4967 { 4968 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n", 4969 snd_hda_codec_read(codec, codec->afg, 0, verb, 0)); 4970 } 4971 4972 /* stac92hd71bxx, stac92hd73xx */ 4973 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer, 4974 struct hda_codec *codec, hda_nid_t nid) 4975 { 4976 stac92hd_proc_hook(buffer, codec, nid); 4977 if (nid == codec->afg) 4978 analog_loop_proc_hook(buffer, codec, 0xfa0); 4979 } 4980 4981 static void stac9205_proc_hook(struct snd_info_buffer *buffer, 4982 struct hda_codec *codec, hda_nid_t nid) 4983 { 4984 if (nid == codec->afg) 4985 analog_loop_proc_hook(buffer, codec, 0xfe0); 4986 } 4987 4988 static void stac927x_proc_hook(struct snd_info_buffer *buffer, 4989 struct hda_codec *codec, hda_nid_t nid) 4990 { 4991 if (nid == codec->afg) 4992 analog_loop_proc_hook(buffer, codec, 0xfeb); 4993 } 4994 #else 4995 #define stac92hd_proc_hook NULL 4996 #define stac92hd7x_proc_hook NULL 4997 #define stac9205_proc_hook NULL 4998 #define stac927x_proc_hook NULL 4999 #endif 5000 5001 #ifdef CONFIG_PM 5002 static int stac92xx_resume(struct hda_codec *codec) 5003 { 5004 stac92xx_init(codec); 5005 snd_hda_codec_resume_amp(codec); 5006 snd_hda_codec_resume_cache(codec); 5007 /* fake event to set up pins again to override cached values */ 5008 stac_fake_hp_events(codec); 5009 return 0; 5010 } 5011 5012 static int stac92xx_suspend(struct hda_codec *codec) 5013 { 5014 stac92xx_shutup(codec); 5015 return 0; 5016 } 5017 5018 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg, 5019 unsigned int power_state) 5020 { 5021 unsigned int afg_power_state = power_state; 5022 struct sigmatel_spec *spec = codec->spec; 5023 5024 if (power_state == AC_PWRST_D3) { 5025 if (spec->vref_mute_led_nid) { 5026 /* with vref-out pin used for mute led control 5027 * codec AFG is prevented from D3 state 5028 */ 5029 afg_power_state = AC_PWRST_D1; 5030 } 5031 /* this delay seems necessary to avoid click noise at power-down */ 5032 msleep(100); 5033 } 5034 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, 5035 afg_power_state); 5036 snd_hda_codec_set_power_to_all(codec, fg, power_state, true); 5037 } 5038 #else 5039 #define stac92xx_suspend NULL 5040 #define stac92xx_resume NULL 5041 #define stac92xx_set_power_state NULL 5042 #endif /* CONFIG_PM */ 5043 5044 /* update mute-LED accoring to the master switch */ 5045 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled) 5046 { 5047 struct sigmatel_spec *spec = codec->spec; 5048 int muted = !enabled; 5049 5050 if (!spec->gpio_led) 5051 return; 5052 5053 /* LED state is inverted on these systems */ 5054 if (spec->gpio_led_polarity) 5055 muted = !muted; 5056 5057 if (!spec->vref_mute_led_nid) { 5058 if (muted) 5059 spec->gpio_data |= spec->gpio_led; 5060 else 5061 spec->gpio_data &= ~spec->gpio_led; 5062 stac_gpio_set(codec, spec->gpio_mask, 5063 spec->gpio_dir, spec->gpio_data); 5064 } else { 5065 spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD; 5066 stac_vrefout_set(codec, spec->vref_mute_led_nid, 5067 spec->vref_led); 5068 } 5069 } 5070 5071 static const struct hda_codec_ops stac92xx_patch_ops = { 5072 .build_controls = stac92xx_build_controls, 5073 .build_pcms = stac92xx_build_pcms, 5074 .init = stac92xx_init, 5075 .free = stac92xx_free, 5076 .unsol_event = stac92xx_unsol_event, 5077 #ifdef CONFIG_PM 5078 .suspend = stac92xx_suspend, 5079 .resume = stac92xx_resume, 5080 #endif 5081 .reboot_notify = stac92xx_shutup, 5082 }; 5083 5084 static int patch_stac9200(struct hda_codec *codec) 5085 { 5086 struct sigmatel_spec *spec; 5087 int err; 5088 5089 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5090 if (spec == NULL) 5091 return -ENOMEM; 5092 5093 codec->no_trigger_sense = 1; 5094 codec->spec = spec; 5095 spec->linear_tone_beep = 1; 5096 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids); 5097 spec->pin_nids = stac9200_pin_nids; 5098 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS, 5099 stac9200_models, 5100 stac9200_cfg_tbl); 5101 if (spec->board_config < 0) 5102 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5103 codec->chip_name); 5104 else 5105 stac92xx_set_config_regs(codec, 5106 stac9200_brd_tbl[spec->board_config]); 5107 5108 spec->multiout.max_channels = 2; 5109 spec->multiout.num_dacs = 1; 5110 spec->multiout.dac_nids = stac9200_dac_nids; 5111 spec->adc_nids = stac9200_adc_nids; 5112 spec->mux_nids = stac9200_mux_nids; 5113 spec->num_muxes = 1; 5114 spec->num_dmics = 0; 5115 spec->num_adcs = 1; 5116 spec->num_pwrs = 0; 5117 5118 if (spec->board_config == STAC_9200_M4 || 5119 spec->board_config == STAC_9200_M4_2 || 5120 spec->board_config == STAC_9200_OQO) 5121 spec->init = stac9200_eapd_init; 5122 else 5123 spec->init = stac9200_core_init; 5124 spec->mixer = stac9200_mixer; 5125 5126 if (spec->board_config == STAC_9200_PANASONIC) { 5127 spec->gpio_mask = spec->gpio_dir = 0x09; 5128 spec->gpio_data = 0x00; 5129 } 5130 5131 err = stac9200_parse_auto_config(codec); 5132 if (err < 0) { 5133 stac92xx_free(codec); 5134 return err; 5135 } 5136 5137 /* CF-74 has no headphone detection, and the driver should *NOT* 5138 * do detection and HP/speaker toggle because the hardware does it. 5139 */ 5140 if (spec->board_config == STAC_9200_PANASONIC) 5141 spec->hp_detect = 0; 5142 5143 codec->patch_ops = stac92xx_patch_ops; 5144 5145 return 0; 5146 } 5147 5148 static int patch_stac925x(struct hda_codec *codec) 5149 { 5150 struct sigmatel_spec *spec; 5151 int err; 5152 5153 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5154 if (spec == NULL) 5155 return -ENOMEM; 5156 5157 codec->no_trigger_sense = 1; 5158 codec->spec = spec; 5159 spec->linear_tone_beep = 1; 5160 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids); 5161 spec->pin_nids = stac925x_pin_nids; 5162 5163 /* Check first for codec ID */ 5164 spec->board_config = snd_hda_check_board_codec_sid_config(codec, 5165 STAC_925x_MODELS, 5166 stac925x_models, 5167 stac925x_codec_id_cfg_tbl); 5168 5169 /* Now checks for PCI ID, if codec ID is not found */ 5170 if (spec->board_config < 0) 5171 spec->board_config = snd_hda_check_board_config(codec, 5172 STAC_925x_MODELS, 5173 stac925x_models, 5174 stac925x_cfg_tbl); 5175 again: 5176 if (spec->board_config < 0) 5177 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5178 codec->chip_name); 5179 else 5180 stac92xx_set_config_regs(codec, 5181 stac925x_brd_tbl[spec->board_config]); 5182 5183 spec->multiout.max_channels = 2; 5184 spec->multiout.num_dacs = 1; 5185 spec->multiout.dac_nids = stac925x_dac_nids; 5186 spec->adc_nids = stac925x_adc_nids; 5187 spec->mux_nids = stac925x_mux_nids; 5188 spec->num_muxes = 1; 5189 spec->num_adcs = 1; 5190 spec->num_pwrs = 0; 5191 switch (codec->vendor_id) { 5192 case 0x83847632: /* STAC9202 */ 5193 case 0x83847633: /* STAC9202D */ 5194 case 0x83847636: /* STAC9251 */ 5195 case 0x83847637: /* STAC9251D */ 5196 spec->num_dmics = STAC925X_NUM_DMICS; 5197 spec->dmic_nids = stac925x_dmic_nids; 5198 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids); 5199 spec->dmux_nids = stac925x_dmux_nids; 5200 break; 5201 default: 5202 spec->num_dmics = 0; 5203 break; 5204 } 5205 5206 spec->init = stac925x_core_init; 5207 spec->mixer = stac925x_mixer; 5208 spec->num_caps = 1; 5209 spec->capvols = stac925x_capvols; 5210 spec->capsws = stac925x_capsws; 5211 5212 err = stac92xx_parse_auto_config(codec); 5213 if (!err) { 5214 if (spec->board_config < 0) { 5215 printk(KERN_WARNING "hda_codec: No auto-config is " 5216 "available, default to model=ref\n"); 5217 spec->board_config = STAC_925x_REF; 5218 goto again; 5219 } 5220 err = -EINVAL; 5221 } 5222 if (err < 0) { 5223 stac92xx_free(codec); 5224 return err; 5225 } 5226 5227 codec->patch_ops = stac92xx_patch_ops; 5228 5229 return 0; 5230 } 5231 5232 static int patch_stac92hd73xx(struct hda_codec *codec) 5233 { 5234 struct sigmatel_spec *spec; 5235 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2]; 5236 int err = 0; 5237 int num_dacs; 5238 5239 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5240 if (spec == NULL) 5241 return -ENOMEM; 5242 5243 codec->no_trigger_sense = 1; 5244 codec->spec = spec; 5245 spec->linear_tone_beep = 0; 5246 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs; 5247 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids); 5248 spec->pin_nids = stac92hd73xx_pin_nids; 5249 spec->board_config = snd_hda_check_board_config(codec, 5250 STAC_92HD73XX_MODELS, 5251 stac92hd73xx_models, 5252 stac92hd73xx_cfg_tbl); 5253 /* check codec subsystem id if not found */ 5254 if (spec->board_config < 0) 5255 spec->board_config = 5256 snd_hda_check_board_codec_sid_config(codec, 5257 STAC_92HD73XX_MODELS, stac92hd73xx_models, 5258 stac92hd73xx_codec_id_cfg_tbl); 5259 again: 5260 if (spec->board_config < 0) 5261 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5262 codec->chip_name); 5263 else 5264 stac92xx_set_config_regs(codec, 5265 stac92hd73xx_brd_tbl[spec->board_config]); 5266 5267 num_dacs = snd_hda_get_connections(codec, 0x0a, 5268 conn, STAC92HD73_DAC_COUNT + 2) - 1; 5269 5270 if (num_dacs < 3 || num_dacs > 5) { 5271 printk(KERN_WARNING "hda_codec: Could not determine " 5272 "number of channels defaulting to DAC count\n"); 5273 num_dacs = STAC92HD73_DAC_COUNT; 5274 } 5275 spec->init = stac92hd73xx_core_init; 5276 switch (num_dacs) { 5277 case 0x3: /* 6 Channel */ 5278 spec->aloopback_ctl = stac92hd73xx_6ch_loopback; 5279 break; 5280 case 0x4: /* 8 Channel */ 5281 spec->aloopback_ctl = stac92hd73xx_8ch_loopback; 5282 break; 5283 case 0x5: /* 10 Channel */ 5284 spec->aloopback_ctl = stac92hd73xx_10ch_loopback; 5285 break; 5286 } 5287 spec->multiout.dac_nids = spec->dac_nids; 5288 5289 spec->aloopback_mask = 0x01; 5290 spec->aloopback_shift = 8; 5291 5292 spec->digbeep_nid = 0x1c; 5293 spec->mux_nids = stac92hd73xx_mux_nids; 5294 spec->adc_nids = stac92hd73xx_adc_nids; 5295 spec->dmic_nids = stac92hd73xx_dmic_nids; 5296 spec->dmux_nids = stac92hd73xx_dmux_nids; 5297 spec->smux_nids = stac92hd73xx_smux_nids; 5298 5299 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids); 5300 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids); 5301 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids); 5302 5303 spec->num_caps = STAC92HD73XX_NUM_CAPS; 5304 spec->capvols = stac92hd73xx_capvols; 5305 spec->capsws = stac92hd73xx_capsws; 5306 5307 switch (spec->board_config) { 5308 case STAC_DELL_EQ: 5309 spec->init = dell_eq_core_init; 5310 /* fallthru */ 5311 case STAC_DELL_M6_AMIC: 5312 case STAC_DELL_M6_DMIC: 5313 case STAC_DELL_M6_BOTH: 5314 spec->num_smuxes = 0; 5315 spec->eapd_switch = 0; 5316 5317 switch (spec->board_config) { 5318 case STAC_DELL_M6_AMIC: /* Analog Mics */ 5319 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5320 spec->num_dmics = 0; 5321 break; 5322 case STAC_DELL_M6_DMIC: /* Digital Mics */ 5323 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5324 spec->num_dmics = 1; 5325 break; 5326 case STAC_DELL_M6_BOTH: /* Both */ 5327 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5328 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5329 spec->num_dmics = 1; 5330 break; 5331 } 5332 break; 5333 case STAC_ALIENWARE_M17X: 5334 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5335 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5336 spec->eapd_switch = 0; 5337 break; 5338 default: 5339 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5340 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5341 spec->eapd_switch = 1; 5342 break; 5343 } 5344 if (spec->board_config != STAC_92HD73XX_REF) { 5345 /* GPIO0 High = Enable EAPD */ 5346 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 5347 spec->gpio_data = 0x01; 5348 } 5349 5350 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids); 5351 spec->pwr_nids = stac92hd73xx_pwr_nids; 5352 5353 err = stac92xx_parse_auto_config(codec); 5354 5355 if (!err) { 5356 if (spec->board_config < 0) { 5357 printk(KERN_WARNING "hda_codec: No auto-config is " 5358 "available, default to model=ref\n"); 5359 spec->board_config = STAC_92HD73XX_REF; 5360 goto again; 5361 } 5362 err = -EINVAL; 5363 } 5364 5365 if (err < 0) { 5366 stac92xx_free(codec); 5367 return err; 5368 } 5369 5370 if (spec->board_config == STAC_92HD73XX_NO_JD) 5371 spec->hp_detect = 0; 5372 5373 codec->patch_ops = stac92xx_patch_ops; 5374 5375 codec->proc_widget_hook = stac92hd7x_proc_hook; 5376 5377 return 0; 5378 } 5379 5380 static int hp_bnb2011_with_dock(struct hda_codec *codec) 5381 { 5382 if (codec->vendor_id != 0x111d7605 && 5383 codec->vendor_id != 0x111d76d1) 5384 return 0; 5385 5386 switch (codec->subsystem_id) { 5387 case 0x103c1618: 5388 case 0x103c1619: 5389 case 0x103c161a: 5390 case 0x103c161b: 5391 case 0x103c161c: 5392 case 0x103c161d: 5393 case 0x103c161e: 5394 case 0x103c161f: 5395 5396 case 0x103c162a: 5397 case 0x103c162b: 5398 5399 case 0x103c1630: 5400 case 0x103c1631: 5401 5402 case 0x103c1633: 5403 case 0x103c1634: 5404 case 0x103c1635: 5405 5406 case 0x103c3587: 5407 case 0x103c3588: 5408 case 0x103c3589: 5409 case 0x103c358a: 5410 5411 case 0x103c3667: 5412 case 0x103c3668: 5413 case 0x103c3669: 5414 5415 return 1; 5416 } 5417 return 0; 5418 } 5419 5420 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid) 5421 { 5422 struct sigmatel_spec *spec = codec->spec; 5423 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 5424 int i; 5425 5426 spec->auto_pin_nids[spec->auto_pin_cnt] = nid; 5427 spec->auto_pin_cnt++; 5428 5429 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN && 5430 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) { 5431 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) { 5432 if (nid == stac92hd83xxx_dmic_nids[i]) { 5433 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid; 5434 spec->auto_dmic_cnt++; 5435 } 5436 } 5437 } 5438 } 5439 5440 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid) 5441 { 5442 struct sigmatel_spec *spec = codec->spec; 5443 5444 spec->auto_adc_nids[spec->auto_adc_cnt] = nid; 5445 spec->auto_adc_cnt++; 5446 } 5447 5448 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid) 5449 { 5450 int i, j; 5451 struct sigmatel_spec *spec = codec->spec; 5452 5453 for (i = 0; i < spec->auto_adc_cnt; i++) { 5454 if (get_connection_index(codec, 5455 spec->auto_adc_nids[i], nid) >= 0) { 5456 /* mux and volume for adc_nids[i] */ 5457 if (!spec->auto_mux_nids[i]) { 5458 spec->auto_mux_nids[i] = nid; 5459 /* 92hd codecs capture volume is in mux */ 5460 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid, 5461 3, 0, HDA_OUTPUT); 5462 } 5463 for (j = 0; j < spec->auto_dmic_cnt; j++) { 5464 if (get_connection_index(codec, nid, 5465 spec->auto_dmic_nids[j]) >= 0) { 5466 /* dmux for adc_nids[i] */ 5467 if (!spec->auto_dmux_nids[i]) 5468 spec->auto_dmux_nids[i] = nid; 5469 break; 5470 } 5471 } 5472 break; 5473 } 5474 } 5475 } 5476 5477 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec) 5478 { 5479 hda_nid_t nid, end_nid; 5480 unsigned int wid_caps, wid_type; 5481 struct sigmatel_spec *spec = codec->spec; 5482 5483 end_nid = codec->start_nid + codec->num_nodes; 5484 5485 for (nid = codec->start_nid; nid < end_nid; nid++) { 5486 wid_caps = get_wcaps(codec, nid); 5487 wid_type = get_wcaps_type(wid_caps); 5488 5489 if (wid_type == AC_WID_PIN) 5490 stac92hd8x_add_pin(codec, nid); 5491 5492 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL)) 5493 stac92hd8x_add_adc(codec, nid); 5494 } 5495 5496 for (nid = codec->start_nid; nid < end_nid; nid++) { 5497 wid_caps = get_wcaps(codec, nid); 5498 wid_type = get_wcaps_type(wid_caps); 5499 5500 if (wid_type == AC_WID_AUD_SEL) 5501 stac92hd8x_add_mux(codec, nid); 5502 } 5503 5504 spec->pin_nids = spec->auto_pin_nids; 5505 spec->num_pins = spec->auto_pin_cnt; 5506 spec->adc_nids = spec->auto_adc_nids; 5507 spec->num_adcs = spec->auto_adc_cnt; 5508 spec->capvols = spec->auto_capvols; 5509 spec->capsws = spec->auto_capvols; 5510 spec->num_caps = spec->auto_adc_cnt; 5511 spec->mux_nids = spec->auto_mux_nids; 5512 spec->num_muxes = spec->auto_adc_cnt; 5513 spec->dmux_nids = spec->auto_dmux_nids; 5514 spec->num_dmuxes = spec->auto_adc_cnt; 5515 spec->dmic_nids = spec->auto_dmic_nids; 5516 spec->num_dmics = spec->auto_dmic_cnt; 5517 } 5518 5519 static int patch_stac92hd83xxx(struct hda_codec *codec) 5520 { 5521 struct sigmatel_spec *spec; 5522 int default_polarity = -1; /* no default cfg */ 5523 int err; 5524 5525 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5526 if (spec == NULL) 5527 return -ENOMEM; 5528 5529 if (hp_bnb2011_with_dock(codec)) { 5530 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f); 5531 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e); 5532 } 5533 5534 codec->no_trigger_sense = 1; 5535 codec->spec = spec; 5536 5537 stac92hd8x_fill_auto_spec(codec); 5538 5539 spec->linear_tone_beep = 0; 5540 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs; 5541 spec->digbeep_nid = 0x21; 5542 spec->pwr_nids = stac92hd83xxx_pwr_nids; 5543 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids); 5544 spec->multiout.dac_nids = spec->dac_nids; 5545 spec->init = stac92hd83xxx_core_init; 5546 5547 spec->board_config = snd_hda_check_board_config(codec, 5548 STAC_92HD83XXX_MODELS, 5549 stac92hd83xxx_models, 5550 stac92hd83xxx_cfg_tbl); 5551 /* check codec subsystem id if not found */ 5552 if (spec->board_config < 0) 5553 spec->board_config = 5554 snd_hda_check_board_codec_sid_config(codec, 5555 STAC_92HD83XXX_MODELS, stac92hd83xxx_models, 5556 stac92hd83xxx_codec_id_cfg_tbl); 5557 again: 5558 if (spec->board_config < 0) 5559 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5560 codec->chip_name); 5561 else 5562 stac92xx_set_config_regs(codec, 5563 stac92hd83xxx_brd_tbl[spec->board_config]); 5564 5565 codec->patch_ops = stac92xx_patch_ops; 5566 5567 switch (spec->board_config) { 5568 case STAC_HP_ZEPHYR: 5569 spec->init = stac92hd83xxx_hp_zephyr_init; 5570 break; 5571 case STAC_92HD83XXX_HP_LED: 5572 default_polarity = 0; 5573 break; 5574 case STAC_92HD83XXX_HP_INV_LED: 5575 default_polarity = 1; 5576 break; 5577 } 5578 5579 if (find_mute_led_cfg(codec, default_polarity)) 5580 snd_printd("mute LED gpio %d polarity %d\n", 5581 spec->gpio_led, 5582 spec->gpio_led_polarity); 5583 5584 if (spec->gpio_led) { 5585 if (!spec->vref_mute_led_nid) { 5586 spec->gpio_mask |= spec->gpio_led; 5587 spec->gpio_dir |= spec->gpio_led; 5588 spec->gpio_data |= spec->gpio_led; 5589 } else { 5590 codec->patch_ops.set_power_state = 5591 stac92xx_set_power_state; 5592 } 5593 } 5594 5595 err = stac92xx_parse_auto_config(codec); 5596 if (!err) { 5597 if (spec->board_config < 0) { 5598 printk(KERN_WARNING "hda_codec: No auto-config is " 5599 "available, default to model=ref\n"); 5600 spec->board_config = STAC_92HD83XXX_REF; 5601 goto again; 5602 } 5603 err = -EINVAL; 5604 } 5605 5606 if (err < 0) { 5607 stac92xx_free(codec); 5608 return err; 5609 } 5610 5611 codec->proc_widget_hook = stac92hd_proc_hook; 5612 5613 return 0; 5614 } 5615 5616 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec, 5617 hda_nid_t dig0pin) 5618 { 5619 struct sigmatel_spec *spec = codec->spec; 5620 int idx; 5621 5622 for (idx = 0; idx < spec->num_pins; idx++) 5623 if (spec->pin_nids[idx] == dig0pin) 5624 break; 5625 if ((idx + 2) >= spec->num_pins) 5626 return 0; 5627 5628 /* dig1pin case */ 5629 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE) 5630 return 2; 5631 5632 /* dig0pin + dig2pin case */ 5633 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE) 5634 return 2; 5635 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE) 5636 return 1; 5637 else 5638 return 0; 5639 } 5640 5641 /* HP dv7 bass switch - GPIO5 */ 5642 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info 5643 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol, 5644 struct snd_ctl_elem_value *ucontrol) 5645 { 5646 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5647 struct sigmatel_spec *spec = codec->spec; 5648 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20); 5649 return 0; 5650 } 5651 5652 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol, 5653 struct snd_ctl_elem_value *ucontrol) 5654 { 5655 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5656 struct sigmatel_spec *spec = codec->spec; 5657 unsigned int gpio_data; 5658 5659 gpio_data = (spec->gpio_data & ~0x20) | 5660 (ucontrol->value.integer.value[0] ? 0x20 : 0); 5661 if (gpio_data == spec->gpio_data) 5662 return 0; 5663 spec->gpio_data = gpio_data; 5664 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data); 5665 return 1; 5666 } 5667 5668 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = { 5669 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5670 .info = stac_hp_bass_gpio_info, 5671 .get = stac_hp_bass_gpio_get, 5672 .put = stac_hp_bass_gpio_put, 5673 }; 5674 5675 static int stac_add_hp_bass_switch(struct hda_codec *codec) 5676 { 5677 struct sigmatel_spec *spec = codec->spec; 5678 5679 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl, 5680 "Bass Speaker Playback Switch", 0)) 5681 return -ENOMEM; 5682 5683 spec->gpio_mask |= 0x20; 5684 spec->gpio_dir |= 0x20; 5685 spec->gpio_data |= 0x20; 5686 return 0; 5687 } 5688 5689 static int patch_stac92hd71bxx(struct hda_codec *codec) 5690 { 5691 struct sigmatel_spec *spec; 5692 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init; 5693 unsigned int pin_cfg; 5694 int err = 0; 5695 5696 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5697 if (spec == NULL) 5698 return -ENOMEM; 5699 5700 codec->no_trigger_sense = 1; 5701 codec->spec = spec; 5702 spec->linear_tone_beep = 0; 5703 codec->patch_ops = stac92xx_patch_ops; 5704 spec->num_pins = STAC92HD71BXX_NUM_PINS; 5705 switch (codec->vendor_id) { 5706 case 0x111d76b6: 5707 case 0x111d76b7: 5708 spec->pin_nids = stac92hd71bxx_pin_nids_4port; 5709 break; 5710 case 0x111d7603: 5711 case 0x111d7608: 5712 /* On 92HD75Bx 0x27 isn't a pin nid */ 5713 spec->num_pins--; 5714 /* fallthrough */ 5715 default: 5716 spec->pin_nids = stac92hd71bxx_pin_nids_6port; 5717 } 5718 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids); 5719 spec->board_config = snd_hda_check_board_config(codec, 5720 STAC_92HD71BXX_MODELS, 5721 stac92hd71bxx_models, 5722 stac92hd71bxx_cfg_tbl); 5723 again: 5724 if (spec->board_config < 0) 5725 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5726 codec->chip_name); 5727 else 5728 stac92xx_set_config_regs(codec, 5729 stac92hd71bxx_brd_tbl[spec->board_config]); 5730 5731 if (spec->board_config != STAC_92HD71BXX_REF) { 5732 /* GPIO0 = EAPD */ 5733 spec->gpio_mask = 0x01; 5734 spec->gpio_dir = 0x01; 5735 spec->gpio_data = 0x01; 5736 } 5737 5738 spec->dmic_nids = stac92hd71bxx_dmic_nids; 5739 spec->dmux_nids = stac92hd71bxx_dmux_nids; 5740 5741 spec->num_caps = STAC92HD71BXX_NUM_CAPS; 5742 spec->capvols = stac92hd71bxx_capvols; 5743 spec->capsws = stac92hd71bxx_capsws; 5744 5745 switch (codec->vendor_id) { 5746 case 0x111d76b6: /* 4 Port without Analog Mixer */ 5747 case 0x111d76b7: 5748 unmute_init++; 5749 /* fallthru */ 5750 case 0x111d76b4: /* 6 Port without Analog Mixer */ 5751 case 0x111d76b5: 5752 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5753 spec->num_dmics = stac92xx_connected_ports(codec, 5754 stac92hd71bxx_dmic_nids, 5755 STAC92HD71BXX_NUM_DMICS); 5756 break; 5757 case 0x111d7608: /* 5 Port with Analog Mixer */ 5758 switch (spec->board_config) { 5759 case STAC_HP_M4: 5760 /* Enable VREF power saving on GPIO1 detect */ 5761 err = stac_add_event(codec, codec->afg, 5762 STAC_VREF_EVENT, 0x02); 5763 if (err < 0) 5764 return err; 5765 snd_hda_codec_write_cache(codec, codec->afg, 0, 5766 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02); 5767 snd_hda_jack_detect_enable(codec, codec->afg, 0); 5768 spec->gpio_mask |= 0x02; 5769 break; 5770 } 5771 if ((codec->revision_id & 0xf) == 0 || 5772 (codec->revision_id & 0xf) == 1) 5773 spec->stream_delay = 40; /* 40 milliseconds */ 5774 5775 /* disable VSW */ 5776 unmute_init++; 5777 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); 5778 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); 5779 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids; 5780 spec->num_dmics = stac92xx_connected_ports(codec, 5781 stac92hd71bxx_dmic_5port_nids, 5782 STAC92HD71BXX_NUM_DMICS - 1); 5783 break; 5784 case 0x111d7603: /* 6 Port with Analog Mixer */ 5785 if ((codec->revision_id & 0xf) == 1) 5786 spec->stream_delay = 40; /* 40 milliseconds */ 5787 5788 /* fallthru */ 5789 default: 5790 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5791 spec->num_dmics = stac92xx_connected_ports(codec, 5792 stac92hd71bxx_dmic_nids, 5793 STAC92HD71BXX_NUM_DMICS); 5794 break; 5795 } 5796 5797 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB) 5798 spec->init = stac92hd71bxx_core_init; 5799 5800 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) 5801 snd_hda_sequence_write_cache(codec, unmute_init); 5802 5803 spec->aloopback_ctl = stac92hd71bxx_loopback; 5804 spec->aloopback_mask = 0x50; 5805 spec->aloopback_shift = 0; 5806 5807 spec->powerdown_adcs = 1; 5808 spec->digbeep_nid = 0x26; 5809 spec->mux_nids = stac92hd71bxx_mux_nids; 5810 spec->adc_nids = stac92hd71bxx_adc_nids; 5811 spec->smux_nids = stac92hd71bxx_smux_nids; 5812 spec->pwr_nids = stac92hd71bxx_pwr_nids; 5813 5814 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids); 5815 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids); 5816 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids); 5817 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e); 5818 5819 snd_printdd("Found board config: %d\n", spec->board_config); 5820 5821 switch (spec->board_config) { 5822 case STAC_HP_M4: 5823 /* enable internal microphone */ 5824 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040); 5825 stac92xx_auto_set_pinctl(codec, 0x0e, 5826 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80); 5827 /* fallthru */ 5828 case STAC_DELL_M4_2: 5829 spec->num_dmics = 0; 5830 spec->num_smuxes = 0; 5831 spec->num_dmuxes = 0; 5832 break; 5833 case STAC_DELL_M4_1: 5834 case STAC_DELL_M4_3: 5835 spec->num_dmics = 1; 5836 spec->num_smuxes = 0; 5837 spec->num_dmuxes = 1; 5838 break; 5839 case STAC_HP_DV4_1222NR: 5840 spec->num_dmics = 1; 5841 /* I don't know if it needs 1 or 2 smuxes - will wait for 5842 * bug reports to fix if needed 5843 */ 5844 spec->num_smuxes = 1; 5845 spec->num_dmuxes = 1; 5846 /* fallthrough */ 5847 case STAC_HP_DV4: 5848 spec->gpio_led = 0x01; 5849 /* fallthrough */ 5850 case STAC_HP_DV5: 5851 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010); 5852 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN); 5853 /* HP dv6 gives the headphone pin as a line-out. Thus we 5854 * need to set hp_detect flag here to force to enable HP 5855 * detection. 5856 */ 5857 spec->hp_detect = 1; 5858 break; 5859 case STAC_HP_HDX: 5860 spec->num_dmics = 1; 5861 spec->num_dmuxes = 1; 5862 spec->num_smuxes = 1; 5863 spec->gpio_led = 0x08; 5864 break; 5865 } 5866 5867 if (hp_blike_system(codec->subsystem_id)) { 5868 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f); 5869 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT || 5870 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER || 5871 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) { 5872 /* It was changed in the BIOS to just satisfy MS DTM. 5873 * Lets turn it back into slaved HP 5874 */ 5875 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE)) 5876 | (AC_JACK_HP_OUT << 5877 AC_DEFCFG_DEVICE_SHIFT); 5878 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC 5879 | AC_DEFCFG_SEQUENCE))) 5880 | 0x1f; 5881 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg); 5882 } 5883 } 5884 5885 if (find_mute_led_cfg(codec, 1)) 5886 snd_printd("mute LED gpio %d polarity %d\n", 5887 spec->gpio_led, 5888 spec->gpio_led_polarity); 5889 5890 if (spec->gpio_led) { 5891 if (!spec->vref_mute_led_nid) { 5892 spec->gpio_mask |= spec->gpio_led; 5893 spec->gpio_dir |= spec->gpio_led; 5894 spec->gpio_data |= spec->gpio_led; 5895 } else { 5896 codec->patch_ops.set_power_state = 5897 stac92xx_set_power_state; 5898 } 5899 } 5900 5901 spec->multiout.dac_nids = spec->dac_nids; 5902 5903 err = stac92xx_parse_auto_config(codec); 5904 if (!err) { 5905 if (spec->board_config < 0) { 5906 printk(KERN_WARNING "hda_codec: No auto-config is " 5907 "available, default to model=ref\n"); 5908 spec->board_config = STAC_92HD71BXX_REF; 5909 goto again; 5910 } 5911 err = -EINVAL; 5912 } 5913 5914 if (err < 0) { 5915 stac92xx_free(codec); 5916 return err; 5917 } 5918 5919 /* enable bass on HP dv7 */ 5920 if (spec->board_config == STAC_HP_DV4 || 5921 spec->board_config == STAC_HP_DV5) { 5922 unsigned int cap; 5923 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP); 5924 cap &= AC_GPIO_IO_COUNT; 5925 if (cap >= 6) 5926 stac_add_hp_bass_switch(codec); 5927 } 5928 5929 codec->proc_widget_hook = stac92hd7x_proc_hook; 5930 5931 return 0; 5932 } 5933 5934 static int patch_stac922x(struct hda_codec *codec) 5935 { 5936 struct sigmatel_spec *spec; 5937 int err; 5938 5939 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5940 if (spec == NULL) 5941 return -ENOMEM; 5942 5943 codec->no_trigger_sense = 1; 5944 codec->spec = spec; 5945 spec->linear_tone_beep = 1; 5946 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids); 5947 spec->pin_nids = stac922x_pin_nids; 5948 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS, 5949 stac922x_models, 5950 stac922x_cfg_tbl); 5951 if (spec->board_config == STAC_INTEL_MAC_AUTO) { 5952 spec->gpio_mask = spec->gpio_dir = 0x03; 5953 spec->gpio_data = 0x03; 5954 /* Intel Macs have all same PCI SSID, so we need to check 5955 * codec SSID to distinguish the exact models 5956 */ 5957 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id); 5958 switch (codec->subsystem_id) { 5959 5960 case 0x106b0800: 5961 spec->board_config = STAC_INTEL_MAC_V1; 5962 break; 5963 case 0x106b0600: 5964 case 0x106b0700: 5965 spec->board_config = STAC_INTEL_MAC_V2; 5966 break; 5967 case 0x106b0e00: 5968 case 0x106b0f00: 5969 case 0x106b1600: 5970 case 0x106b1700: 5971 case 0x106b0200: 5972 case 0x106b1e00: 5973 spec->board_config = STAC_INTEL_MAC_V3; 5974 break; 5975 case 0x106b1a00: 5976 case 0x00000100: 5977 spec->board_config = STAC_INTEL_MAC_V4; 5978 break; 5979 case 0x106b0a00: 5980 case 0x106b2200: 5981 spec->board_config = STAC_INTEL_MAC_V5; 5982 break; 5983 default: 5984 spec->board_config = STAC_INTEL_MAC_V3; 5985 break; 5986 } 5987 } 5988 5989 again: 5990 if (spec->board_config < 0) 5991 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5992 codec->chip_name); 5993 else 5994 stac92xx_set_config_regs(codec, 5995 stac922x_brd_tbl[spec->board_config]); 5996 5997 spec->adc_nids = stac922x_adc_nids; 5998 spec->mux_nids = stac922x_mux_nids; 5999 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids); 6000 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids); 6001 spec->num_dmics = 0; 6002 spec->num_pwrs = 0; 6003 6004 spec->init = stac922x_core_init; 6005 6006 spec->num_caps = STAC922X_NUM_CAPS; 6007 spec->capvols = stac922x_capvols; 6008 spec->capsws = stac922x_capsws; 6009 6010 spec->multiout.dac_nids = spec->dac_nids; 6011 6012 err = stac92xx_parse_auto_config(codec); 6013 if (!err) { 6014 if (spec->board_config < 0) { 6015 printk(KERN_WARNING "hda_codec: No auto-config is " 6016 "available, default to model=ref\n"); 6017 spec->board_config = STAC_D945_REF; 6018 goto again; 6019 } 6020 err = -EINVAL; 6021 } 6022 if (err < 0) { 6023 stac92xx_free(codec); 6024 return err; 6025 } 6026 6027 codec->patch_ops = stac92xx_patch_ops; 6028 6029 /* Fix Mux capture level; max to 2 */ 6030 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT, 6031 (0 << AC_AMPCAP_OFFSET_SHIFT) | 6032 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6033 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) | 6034 (0 << AC_AMPCAP_MUTE_SHIFT)); 6035 6036 return 0; 6037 } 6038 6039 static int patch_stac927x(struct hda_codec *codec) 6040 { 6041 struct sigmatel_spec *spec; 6042 int err; 6043 6044 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6045 if (spec == NULL) 6046 return -ENOMEM; 6047 6048 codec->no_trigger_sense = 1; 6049 codec->spec = spec; 6050 spec->linear_tone_beep = 1; 6051 codec->slave_dig_outs = stac927x_slave_dig_outs; 6052 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids); 6053 spec->pin_nids = stac927x_pin_nids; 6054 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS, 6055 stac927x_models, 6056 stac927x_cfg_tbl); 6057 again: 6058 if (spec->board_config < 0) 6059 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6060 codec->chip_name); 6061 else 6062 stac92xx_set_config_regs(codec, 6063 stac927x_brd_tbl[spec->board_config]); 6064 6065 spec->digbeep_nid = 0x23; 6066 spec->adc_nids = stac927x_adc_nids; 6067 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids); 6068 spec->mux_nids = stac927x_mux_nids; 6069 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids); 6070 spec->smux_nids = stac927x_smux_nids; 6071 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids); 6072 spec->spdif_labels = stac927x_spdif_labels; 6073 spec->dac_list = stac927x_dac_nids; 6074 spec->multiout.dac_nids = spec->dac_nids; 6075 6076 if (spec->board_config != STAC_D965_REF) { 6077 /* GPIO0 High = Enable EAPD */ 6078 spec->eapd_mask = spec->gpio_mask = 0x01; 6079 spec->gpio_dir = spec->gpio_data = 0x01; 6080 } 6081 6082 switch (spec->board_config) { 6083 case STAC_D965_3ST: 6084 case STAC_D965_5ST: 6085 /* GPIO0 High = Enable EAPD */ 6086 spec->num_dmics = 0; 6087 spec->init = d965_core_init; 6088 break; 6089 case STAC_DELL_BIOS: 6090 switch (codec->subsystem_id) { 6091 case 0x10280209: 6092 case 0x1028022e: 6093 /* correct the device field to SPDIF out */ 6094 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070); 6095 break; 6096 } 6097 /* configure the analog microphone on some laptops */ 6098 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130); 6099 /* correct the front output jack as a hp out */ 6100 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f); 6101 /* correct the front input jack as a mic */ 6102 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130); 6103 /* fallthru */ 6104 case STAC_DELL_3ST: 6105 if (codec->subsystem_id != 0x1028022f) { 6106 /* GPIO2 High = Enable EAPD */ 6107 spec->eapd_mask = spec->gpio_mask = 0x04; 6108 spec->gpio_dir = spec->gpio_data = 0x04; 6109 } 6110 spec->dmic_nids = stac927x_dmic_nids; 6111 spec->num_dmics = STAC927X_NUM_DMICS; 6112 6113 spec->init = dell_3st_core_init; 6114 spec->dmux_nids = stac927x_dmux_nids; 6115 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids); 6116 break; 6117 case STAC_927X_VOLKNOB: 6118 spec->num_dmics = 0; 6119 spec->init = stac927x_volknob_core_init; 6120 break; 6121 default: 6122 spec->num_dmics = 0; 6123 spec->init = stac927x_core_init; 6124 break; 6125 } 6126 6127 spec->num_caps = STAC927X_NUM_CAPS; 6128 spec->capvols = stac927x_capvols; 6129 spec->capsws = stac927x_capsws; 6130 6131 spec->num_pwrs = 0; 6132 spec->aloopback_ctl = stac927x_loopback; 6133 spec->aloopback_mask = 0x40; 6134 spec->aloopback_shift = 0; 6135 spec->eapd_switch = 1; 6136 6137 err = stac92xx_parse_auto_config(codec); 6138 if (!err) { 6139 if (spec->board_config < 0) { 6140 printk(KERN_WARNING "hda_codec: No auto-config is " 6141 "available, default to model=ref\n"); 6142 spec->board_config = STAC_D965_REF; 6143 goto again; 6144 } 6145 err = -EINVAL; 6146 } 6147 if (err < 0) { 6148 stac92xx_free(codec); 6149 return err; 6150 } 6151 6152 codec->patch_ops = stac92xx_patch_ops; 6153 6154 codec->proc_widget_hook = stac927x_proc_hook; 6155 6156 /* 6157 * !!FIXME!! 6158 * The STAC927x seem to require fairly long delays for certain 6159 * command sequences. With too short delays (even if the answer 6160 * is set to RIRB properly), it results in the silence output 6161 * on some hardwares like Dell. 6162 * 6163 * The below flag enables the longer delay (see get_response 6164 * in hda_intel.c). 6165 */ 6166 codec->bus->needs_damn_long_delay = 1; 6167 6168 /* no jack detecion for ref-no-jd model */ 6169 if (spec->board_config == STAC_D965_REF_NO_JD) 6170 spec->hp_detect = 0; 6171 6172 return 0; 6173 } 6174 6175 static int patch_stac9205(struct hda_codec *codec) 6176 { 6177 struct sigmatel_spec *spec; 6178 int err; 6179 6180 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6181 if (spec == NULL) 6182 return -ENOMEM; 6183 6184 codec->no_trigger_sense = 1; 6185 codec->spec = spec; 6186 spec->linear_tone_beep = 1; 6187 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids); 6188 spec->pin_nids = stac9205_pin_nids; 6189 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS, 6190 stac9205_models, 6191 stac9205_cfg_tbl); 6192 again: 6193 if (spec->board_config < 0) 6194 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6195 codec->chip_name); 6196 else 6197 stac92xx_set_config_regs(codec, 6198 stac9205_brd_tbl[spec->board_config]); 6199 6200 spec->digbeep_nid = 0x23; 6201 spec->adc_nids = stac9205_adc_nids; 6202 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids); 6203 spec->mux_nids = stac9205_mux_nids; 6204 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids); 6205 spec->smux_nids = stac9205_smux_nids; 6206 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids); 6207 spec->dmic_nids = stac9205_dmic_nids; 6208 spec->num_dmics = STAC9205_NUM_DMICS; 6209 spec->dmux_nids = stac9205_dmux_nids; 6210 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids); 6211 spec->num_pwrs = 0; 6212 6213 spec->init = stac9205_core_init; 6214 spec->aloopback_ctl = stac9205_loopback; 6215 6216 spec->num_caps = STAC9205_NUM_CAPS; 6217 spec->capvols = stac9205_capvols; 6218 spec->capsws = stac9205_capsws; 6219 6220 spec->aloopback_mask = 0x40; 6221 spec->aloopback_shift = 0; 6222 /* Turn on/off EAPD per HP plugging */ 6223 if (spec->board_config != STAC_9205_EAPD) 6224 spec->eapd_switch = 1; 6225 spec->multiout.dac_nids = spec->dac_nids; 6226 6227 switch (spec->board_config){ 6228 case STAC_9205_DELL_M43: 6229 /* Enable SPDIF in/out */ 6230 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030); 6231 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030); 6232 6233 /* Enable unsol response for GPIO4/Dock HP connection */ 6234 err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01); 6235 if (err < 0) 6236 return err; 6237 snd_hda_codec_write_cache(codec, codec->afg, 0, 6238 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10); 6239 snd_hda_jack_detect_enable(codec, codec->afg, 0); 6240 6241 spec->gpio_dir = 0x0b; 6242 spec->eapd_mask = 0x01; 6243 spec->gpio_mask = 0x1b; 6244 spec->gpio_mute = 0x10; 6245 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute, 6246 * GPIO3 Low = DRM 6247 */ 6248 spec->gpio_data = 0x01; 6249 break; 6250 case STAC_9205_REF: 6251 /* SPDIF-In enabled */ 6252 break; 6253 default: 6254 /* GPIO0 High = EAPD */ 6255 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 6256 spec->gpio_data = 0x01; 6257 break; 6258 } 6259 6260 err = stac92xx_parse_auto_config(codec); 6261 if (!err) { 6262 if (spec->board_config < 0) { 6263 printk(KERN_WARNING "hda_codec: No auto-config is " 6264 "available, default to model=ref\n"); 6265 spec->board_config = STAC_9205_REF; 6266 goto again; 6267 } 6268 err = -EINVAL; 6269 } 6270 if (err < 0) { 6271 stac92xx_free(codec); 6272 return err; 6273 } 6274 6275 codec->patch_ops = stac92xx_patch_ops; 6276 6277 codec->proc_widget_hook = stac9205_proc_hook; 6278 6279 return 0; 6280 } 6281 6282 /* 6283 * STAC9872 hack 6284 */ 6285 6286 static const struct hda_verb stac9872_core_init[] = { 6287 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */ 6288 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */ 6289 {} 6290 }; 6291 6292 static const hda_nid_t stac9872_pin_nids[] = { 6293 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 6294 0x11, 0x13, 0x14, 6295 }; 6296 6297 static const hda_nid_t stac9872_adc_nids[] = { 6298 0x8 /*,0x6*/ 6299 }; 6300 6301 static const hda_nid_t stac9872_mux_nids[] = { 6302 0x15 6303 }; 6304 6305 static const unsigned long stac9872_capvols[] = { 6306 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 6307 }; 6308 #define stac9872_capsws stac9872_capvols 6309 6310 static const unsigned int stac9872_vaio_pin_configs[9] = { 6311 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030, 6312 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0, 6313 0x90a7013e 6314 }; 6315 6316 static const char * const stac9872_models[STAC_9872_MODELS] = { 6317 [STAC_9872_AUTO] = "auto", 6318 [STAC_9872_VAIO] = "vaio", 6319 }; 6320 6321 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = { 6322 [STAC_9872_VAIO] = stac9872_vaio_pin_configs, 6323 }; 6324 6325 static const struct snd_pci_quirk stac9872_cfg_tbl[] = { 6326 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0, 6327 "Sony VAIO F/S", STAC_9872_VAIO), 6328 {} /* terminator */ 6329 }; 6330 6331 static int patch_stac9872(struct hda_codec *codec) 6332 { 6333 struct sigmatel_spec *spec; 6334 int err; 6335 6336 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6337 if (spec == NULL) 6338 return -ENOMEM; 6339 codec->no_trigger_sense = 1; 6340 codec->spec = spec; 6341 spec->linear_tone_beep = 1; 6342 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids); 6343 spec->pin_nids = stac9872_pin_nids; 6344 6345 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS, 6346 stac9872_models, 6347 stac9872_cfg_tbl); 6348 if (spec->board_config < 0) 6349 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6350 codec->chip_name); 6351 else 6352 stac92xx_set_config_regs(codec, 6353 stac9872_brd_tbl[spec->board_config]); 6354 6355 spec->multiout.dac_nids = spec->dac_nids; 6356 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids); 6357 spec->adc_nids = stac9872_adc_nids; 6358 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids); 6359 spec->mux_nids = stac9872_mux_nids; 6360 spec->init = stac9872_core_init; 6361 spec->num_caps = 1; 6362 spec->capvols = stac9872_capvols; 6363 spec->capsws = stac9872_capsws; 6364 6365 err = stac92xx_parse_auto_config(codec); 6366 if (err < 0) { 6367 stac92xx_free(codec); 6368 return -EINVAL; 6369 } 6370 spec->input_mux = &spec->private_imux; 6371 codec->patch_ops = stac92xx_patch_ops; 6372 return 0; 6373 } 6374 6375 6376 /* 6377 * patch entries 6378 */ 6379 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = { 6380 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 }, 6381 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x }, 6382 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x }, 6383 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x }, 6384 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x }, 6385 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x }, 6386 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x }, 6387 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x }, 6388 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x }, 6389 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x }, 6390 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x }, 6391 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x }, 6392 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x }, 6393 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x }, 6394 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x }, 6395 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x }, 6396 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x }, 6397 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x }, 6398 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x }, 6399 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x }, 6400 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x }, 6401 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x }, 6402 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x }, 6403 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x }, 6404 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x }, 6405 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x }, 6406 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x }, 6407 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x }, 6408 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x }, 6409 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x }, 6410 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x }, 6411 /* The following does not take into account .id=0x83847661 when subsys = 6412 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are 6413 * currently not fully supported. 6414 */ 6415 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 }, 6416 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 }, 6417 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 }, 6418 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 }, 6419 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 }, 6420 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 }, 6421 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 }, 6422 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 }, 6423 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 }, 6424 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 }, 6425 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 }, 6426 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 }, 6427 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx}, 6428 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx}, 6429 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx}, 6430 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx}, 6431 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx}, 6432 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx}, 6433 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx}, 6434 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx}, 6435 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx}, 6436 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx}, 6437 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx}, 6438 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx}, 6439 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx }, 6440 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx }, 6441 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx }, 6442 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6443 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6444 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6445 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6446 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6447 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6448 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6449 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6450 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx }, 6451 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx }, 6452 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx }, 6453 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx }, 6454 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx }, 6455 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx }, 6456 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx }, 6457 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx }, 6458 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx }, 6459 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx }, 6460 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx }, 6461 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx }, 6462 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx }, 6463 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx }, 6464 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx }, 6465 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx}, 6466 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx}, 6467 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx}, 6468 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx}, 6469 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx}, 6470 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx}, 6471 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx}, 6472 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx}, 6473 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx}, 6474 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx}, 6475 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx}, 6476 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx}, 6477 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx}, 6478 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx}, 6479 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx}, 6480 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx}, 6481 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx}, 6482 {} /* terminator */ 6483 }; 6484 6485 MODULE_ALIAS("snd-hda-codec-id:8384*"); 6486 MODULE_ALIAS("snd-hda-codec-id:111d*"); 6487 6488 MODULE_LICENSE("GPL"); 6489 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec"); 6490 6491 static struct hda_codec_preset_list sigmatel_list = { 6492 .preset = snd_hda_preset_sigmatel, 6493 .owner = THIS_MODULE, 6494 }; 6495 6496 static int __init patch_sigmatel_init(void) 6497 { 6498 return snd_hda_add_codec_preset(&sigmatel_list); 6499 } 6500 6501 static void __exit patch_sigmatel_exit(void) 6502 { 6503 snd_hda_delete_codec_preset(&sigmatel_list); 6504 } 6505 6506 module_init(patch_sigmatel_init) 6507 module_exit(patch_sigmatel_exit) 6508