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