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