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 {} /* terminator */ 1767 }; 1768 1769 static const struct snd_pci_quirk stac92hd83xxx_codec_id_cfg_tbl[] = { 1770 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3561, 1771 "HP", STAC_HP_ZEPHYR), 1772 {} /* terminator */ 1773 }; 1774 1775 static const unsigned int ref92hd71bxx_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1776 0x02214030, 0x02a19040, 0x01a19020, 0x01014010, 1777 0x0181302e, 0x01014010, 0x01019020, 0x90a000f0, 1778 0x90a000f0, 0x01452050, 0x01452050, 0x00000000, 1779 0x00000000 1780 }; 1781 1782 static const unsigned int dell_m4_1_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1783 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110, 1784 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0, 1785 0x40f000f0, 0x4f0000f0, 0x4f0000f0, 0x00000000, 1786 0x00000000 1787 }; 1788 1789 static const unsigned int dell_m4_2_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1790 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 1791 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0, 1792 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000, 1793 0x00000000 1794 }; 1795 1796 static const unsigned int dell_m4_3_pin_configs[STAC92HD71BXX_NUM_PINS] = { 1797 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 1798 0x40f000f0, 0x40f000f0, 0x40f000f0, 0x90a000f0, 1799 0x40f000f0, 0x044413b0, 0x044413b0, 0x00000000, 1800 0x00000000 1801 }; 1802 1803 static const unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = { 1804 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs, 1805 [STAC_DELL_M4_1] = dell_m4_1_pin_configs, 1806 [STAC_DELL_M4_2] = dell_m4_2_pin_configs, 1807 [STAC_DELL_M4_3] = dell_m4_3_pin_configs, 1808 [STAC_HP_M4] = NULL, 1809 [STAC_HP_DV4] = NULL, 1810 [STAC_HP_DV5] = NULL, 1811 [STAC_HP_HDX] = NULL, 1812 [STAC_HP_DV4_1222NR] = NULL, 1813 }; 1814 1815 static const char * const stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = { 1816 [STAC_92HD71BXX_AUTO] = "auto", 1817 [STAC_92HD71BXX_REF] = "ref", 1818 [STAC_DELL_M4_1] = "dell-m4-1", 1819 [STAC_DELL_M4_2] = "dell-m4-2", 1820 [STAC_DELL_M4_3] = "dell-m4-3", 1821 [STAC_HP_M4] = "hp-m4", 1822 [STAC_HP_DV4] = "hp-dv4", 1823 [STAC_HP_DV5] = "hp-dv5", 1824 [STAC_HP_HDX] = "hp-hdx", 1825 [STAC_HP_DV4_1222NR] = "hp-dv4-1222nr", 1826 }; 1827 1828 static const struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = { 1829 /* SigmaTel reference board */ 1830 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1831 "DFI LanParty", STAC_92HD71BXX_REF), 1832 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 1833 "DFI LanParty", STAC_92HD71BXX_REF), 1834 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x30fb, 1835 "HP dv4-1222nr", STAC_HP_DV4_1222NR), 1836 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x1720, 1837 "HP", STAC_HP_DV5), 1838 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3080, 1839 "HP", STAC_HP_DV5), 1840 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x30f0, 1841 "HP dv4-7", STAC_HP_DV4), 1842 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3600, 1843 "HP dv4-7", STAC_HP_DV5), 1844 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3610, 1845 "HP HDX", STAC_HP_HDX), /* HDX18 */ 1846 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361a, 1847 "HP mini 1000", STAC_HP_M4), 1848 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x361b, 1849 "HP HDX", STAC_HP_HDX), /* HDX16 */ 1850 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x3620, 1851 "HP dv6", STAC_HP_DV5), 1852 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x3061, 1853 "HP dv6", STAC_HP_DV5), /* HP dv6-1110ax */ 1854 SND_PCI_QUIRK(PCI_VENDOR_ID_HP, 0x363e, 1855 "HP DV6", STAC_HP_DV5), 1856 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_HP, 0xfff0, 0x7010, 1857 "HP", STAC_HP_DV5), 1858 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233, 1859 "unknown Dell", STAC_DELL_M4_1), 1860 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234, 1861 "unknown Dell", STAC_DELL_M4_1), 1862 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250, 1863 "unknown Dell", STAC_DELL_M4_1), 1864 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f, 1865 "unknown Dell", STAC_DELL_M4_1), 1866 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d, 1867 "unknown Dell", STAC_DELL_M4_1), 1868 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251, 1869 "unknown Dell", STAC_DELL_M4_1), 1870 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277, 1871 "unknown Dell", STAC_DELL_M4_1), 1872 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263, 1873 "unknown Dell", STAC_DELL_M4_2), 1874 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265, 1875 "unknown Dell", STAC_DELL_M4_2), 1876 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262, 1877 "unknown Dell", STAC_DELL_M4_2), 1878 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264, 1879 "unknown Dell", STAC_DELL_M4_2), 1880 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02aa, 1881 "unknown Dell", STAC_DELL_M4_3), 1882 {} /* terminator */ 1883 }; 1884 1885 static const unsigned int ref922x_pin_configs[10] = { 1886 0x01014010, 0x01016011, 0x01012012, 0x0221401f, 1887 0x01813122, 0x01011014, 0x01441030, 0x01c41030, 1888 0x40000100, 0x40000100, 1889 }; 1890 1891 /* 1892 STAC 922X pin configs for 1893 102801A7 1894 102801AB 1895 102801A9 1896 102801D1 1897 102801D2 1898 */ 1899 static const unsigned int dell_922x_d81_pin_configs[10] = { 1900 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1901 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1, 1902 0x01813122, 0x400001f2, 1903 }; 1904 1905 /* 1906 STAC 922X pin configs for 1907 102801AC 1908 102801D0 1909 */ 1910 static const unsigned int dell_922x_d82_pin_configs[10] = { 1911 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1912 0x02a19020, 0x01117011, 0x01451140, 0x400001f0, 1913 0x01813122, 0x400001f1, 1914 }; 1915 1916 /* 1917 STAC 922X pin configs for 1918 102801BF 1919 */ 1920 static const unsigned int dell_922x_m81_pin_configs[10] = { 1921 0x0321101f, 0x01112024, 0x01111222, 0x91174220, 1922 0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 1923 0x40C003f1, 0x405003f0, 1924 }; 1925 1926 /* 1927 STAC 9221 A1 pin configs for 1928 102801D7 (Dell XPS M1210) 1929 */ 1930 static const unsigned int dell_922x_m82_pin_configs[10] = { 1931 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 1932 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 1933 0x508003f3, 0x405003f4, 1934 }; 1935 1936 static const unsigned int d945gtp3_pin_configs[10] = { 1937 0x0221401f, 0x01a19022, 0x01813021, 0x01014010, 1938 0x40000100, 0x40000100, 0x40000100, 0x40000100, 1939 0x02a19120, 0x40000100, 1940 }; 1941 1942 static const unsigned int d945gtp5_pin_configs[10] = { 1943 0x0221401f, 0x01011012, 0x01813024, 0x01014010, 1944 0x01a19021, 0x01016011, 0x01452130, 0x40000100, 1945 0x02a19320, 0x40000100, 1946 }; 1947 1948 static const unsigned int intel_mac_v1_pin_configs[10] = { 1949 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd, 1950 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240, 1951 0x400000fc, 0x400000fb, 1952 }; 1953 1954 static const unsigned int intel_mac_v2_pin_configs[10] = { 1955 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1956 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa, 1957 0x400000fc, 0x400000fb, 1958 }; 1959 1960 static const unsigned int intel_mac_v3_pin_configs[10] = { 1961 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1962 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240, 1963 0x400000fc, 0x400000fb, 1964 }; 1965 1966 static const unsigned int intel_mac_v4_pin_configs[10] = { 1967 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1968 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1969 0x400000fc, 0x400000fb, 1970 }; 1971 1972 static const unsigned int intel_mac_v5_pin_configs[10] = { 1973 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1974 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1975 0x400000fc, 0x400000fb, 1976 }; 1977 1978 static const unsigned int ecs202_pin_configs[10] = { 1979 0x0221401f, 0x02a19020, 0x01a19020, 0x01114010, 1980 0x408000f0, 0x01813022, 0x074510a0, 0x40c400f1, 1981 0x9037012e, 0x40e000f2, 1982 }; 1983 1984 static const unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = { 1985 [STAC_D945_REF] = ref922x_pin_configs, 1986 [STAC_D945GTP3] = d945gtp3_pin_configs, 1987 [STAC_D945GTP5] = d945gtp5_pin_configs, 1988 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs, 1989 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs, 1990 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs, 1991 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs, 1992 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs, 1993 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs, 1994 /* for backward compatibility */ 1995 [STAC_MACMINI] = intel_mac_v3_pin_configs, 1996 [STAC_MACBOOK] = intel_mac_v5_pin_configs, 1997 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs, 1998 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs, 1999 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs, 2000 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs, 2001 [STAC_ECS_202] = ecs202_pin_configs, 2002 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs, 2003 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs, 2004 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs, 2005 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs, 2006 }; 2007 2008 static const char * const stac922x_models[STAC_922X_MODELS] = { 2009 [STAC_922X_AUTO] = "auto", 2010 [STAC_D945_REF] = "ref", 2011 [STAC_D945GTP5] = "5stack", 2012 [STAC_D945GTP3] = "3stack", 2013 [STAC_INTEL_MAC_V1] = "intel-mac-v1", 2014 [STAC_INTEL_MAC_V2] = "intel-mac-v2", 2015 [STAC_INTEL_MAC_V3] = "intel-mac-v3", 2016 [STAC_INTEL_MAC_V4] = "intel-mac-v4", 2017 [STAC_INTEL_MAC_V5] = "intel-mac-v5", 2018 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto", 2019 /* for backward compatibility */ 2020 [STAC_MACMINI] = "macmini", 2021 [STAC_MACBOOK] = "macbook", 2022 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1", 2023 [STAC_MACBOOK_PRO_V2] = "macbook-pro", 2024 [STAC_IMAC_INTEL] = "imac-intel", 2025 [STAC_IMAC_INTEL_20] = "imac-intel-20", 2026 [STAC_ECS_202] = "ecs202", 2027 [STAC_922X_DELL_D81] = "dell-d81", 2028 [STAC_922X_DELL_D82] = "dell-d82", 2029 [STAC_922X_DELL_M81] = "dell-m81", 2030 [STAC_922X_DELL_M82] = "dell-m82", 2031 }; 2032 2033 static const struct snd_pci_quirk stac922x_cfg_tbl[] = { 2034 /* SigmaTel reference board */ 2035 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2036 "DFI LanParty", STAC_D945_REF), 2037 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2038 "DFI LanParty", STAC_D945_REF), 2039 /* Intel 945G based systems */ 2040 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101, 2041 "Intel D945G", STAC_D945GTP3), 2042 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202, 2043 "Intel D945G", STAC_D945GTP3), 2044 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606, 2045 "Intel D945G", STAC_D945GTP3), 2046 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601, 2047 "Intel D945G", STAC_D945GTP3), 2048 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111, 2049 "Intel D945G", STAC_D945GTP3), 2050 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115, 2051 "Intel D945G", STAC_D945GTP3), 2052 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116, 2053 "Intel D945G", STAC_D945GTP3), 2054 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117, 2055 "Intel D945G", STAC_D945GTP3), 2056 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118, 2057 "Intel D945G", STAC_D945GTP3), 2058 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119, 2059 "Intel D945G", STAC_D945GTP3), 2060 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826, 2061 "Intel D945G", STAC_D945GTP3), 2062 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049, 2063 "Intel D945G", STAC_D945GTP3), 2064 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055, 2065 "Intel D945G", STAC_D945GTP3), 2066 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048, 2067 "Intel D945G", STAC_D945GTP3), 2068 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110, 2069 "Intel D945G", STAC_D945GTP3), 2070 /* Intel D945G 5-stack systems */ 2071 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404, 2072 "Intel D945G", STAC_D945GTP5), 2073 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303, 2074 "Intel D945G", STAC_D945GTP5), 2075 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013, 2076 "Intel D945G", STAC_D945GTP5), 2077 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417, 2078 "Intel D945G", STAC_D945GTP5), 2079 /* Intel 945P based systems */ 2080 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b, 2081 "Intel D945P", STAC_D945GTP3), 2082 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112, 2083 "Intel D945P", STAC_D945GTP3), 2084 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d, 2085 "Intel D945P", STAC_D945GTP3), 2086 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909, 2087 "Intel D945P", STAC_D945GTP3), 2088 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505, 2089 "Intel D945P", STAC_D945GTP3), 2090 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707, 2091 "Intel D945P", STAC_D945GTP5), 2092 /* other intel */ 2093 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0204, 2094 "Intel D945", STAC_D945_REF), 2095 /* other systems */ 2096 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */ 2097 SND_PCI_QUIRK(0x8384, 0x7680, 2098 "Mac", STAC_INTEL_MAC_AUTO), 2099 /* Dell systems */ 2100 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7, 2101 "unknown Dell", STAC_922X_DELL_D81), 2102 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9, 2103 "unknown Dell", STAC_922X_DELL_D81), 2104 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab, 2105 "unknown Dell", STAC_922X_DELL_D81), 2106 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac, 2107 "unknown Dell", STAC_922X_DELL_D82), 2108 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf, 2109 "unknown Dell", STAC_922X_DELL_M81), 2110 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0, 2111 "unknown Dell", STAC_922X_DELL_D82), 2112 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1, 2113 "unknown Dell", STAC_922X_DELL_D81), 2114 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2, 2115 "unknown Dell", STAC_922X_DELL_D81), 2116 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7, 2117 "Dell XPS M1210", STAC_922X_DELL_M82), 2118 /* ECS/PC Chips boards */ 2119 SND_PCI_QUIRK_MASK(0x1019, 0xf000, 0x2000, 2120 "ECS/PC chips", STAC_ECS_202), 2121 {} /* terminator */ 2122 }; 2123 2124 static const unsigned int ref927x_pin_configs[14] = { 2125 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 2126 0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 2127 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070, 2128 0x01c42190, 0x40000100, 2129 }; 2130 2131 static const unsigned int d965_3st_pin_configs[14] = { 2132 0x0221401f, 0x02a19120, 0x40000100, 0x01014011, 2133 0x01a19021, 0x01813024, 0x40000100, 0x40000100, 2134 0x40000100, 0x40000100, 0x40000100, 0x40000100, 2135 0x40000100, 0x40000100 2136 }; 2137 2138 static const unsigned int d965_5st_pin_configs[14] = { 2139 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 2140 0x01a19040, 0x01011012, 0x01016011, 0x40000100, 2141 0x40000100, 0x40000100, 0x40000100, 0x01442070, 2142 0x40000100, 0x40000100 2143 }; 2144 2145 static const unsigned int d965_5st_no_fp_pin_configs[14] = { 2146 0x40000100, 0x40000100, 0x0181304e, 0x01014010, 2147 0x01a19040, 0x01011012, 0x01016011, 0x40000100, 2148 0x40000100, 0x40000100, 0x40000100, 0x01442070, 2149 0x40000100, 0x40000100 2150 }; 2151 2152 static const unsigned int dell_3st_pin_configs[14] = { 2153 0x02211230, 0x02a11220, 0x01a19040, 0x01114210, 2154 0x01111212, 0x01116211, 0x01813050, 0x01112214, 2155 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb, 2156 0x40c003fc, 0x40000100 2157 }; 2158 2159 static const unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = { 2160 [STAC_D965_REF_NO_JD] = ref927x_pin_configs, 2161 [STAC_D965_REF] = ref927x_pin_configs, 2162 [STAC_D965_3ST] = d965_3st_pin_configs, 2163 [STAC_D965_5ST] = d965_5st_pin_configs, 2164 [STAC_D965_5ST_NO_FP] = d965_5st_no_fp_pin_configs, 2165 [STAC_DELL_3ST] = dell_3st_pin_configs, 2166 [STAC_DELL_BIOS] = NULL, 2167 [STAC_927X_VOLKNOB] = NULL, 2168 }; 2169 2170 static const char * const stac927x_models[STAC_927X_MODELS] = { 2171 [STAC_927X_AUTO] = "auto", 2172 [STAC_D965_REF_NO_JD] = "ref-no-jd", 2173 [STAC_D965_REF] = "ref", 2174 [STAC_D965_3ST] = "3stack", 2175 [STAC_D965_5ST] = "5stack", 2176 [STAC_D965_5ST_NO_FP] = "5stack-no-fp", 2177 [STAC_DELL_3ST] = "dell-3stack", 2178 [STAC_DELL_BIOS] = "dell-bios", 2179 [STAC_927X_VOLKNOB] = "volknob", 2180 }; 2181 2182 static const struct snd_pci_quirk stac927x_cfg_tbl[] = { 2183 /* SigmaTel reference board */ 2184 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2185 "DFI LanParty", STAC_D965_REF), 2186 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2187 "DFI LanParty", STAC_D965_REF), 2188 /* Intel 946 based systems */ 2189 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST), 2190 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST), 2191 /* 965 based 3 stack systems */ 2192 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2100, 2193 "Intel D965", STAC_D965_3ST), 2194 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2000, 2195 "Intel D965", STAC_D965_3ST), 2196 /* Dell 3 stack systems */ 2197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST), 2198 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST), 2199 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST), 2200 /* Dell 3 stack systems with verb table in BIOS */ 2201 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS), 2202 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_BIOS), 2203 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS), 2204 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS), 2205 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell Inspiron 1525", STAC_DELL_BIOS), 2206 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS), 2207 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS), 2208 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS), 2209 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS), 2210 /* 965 based 5 stack systems */ 2211 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2300, 2212 "Intel D965", STAC_D965_5ST), 2213 SND_PCI_QUIRK_MASK(PCI_VENDOR_ID_INTEL, 0xff00, 0x2500, 2214 "Intel D965", STAC_D965_5ST), 2215 /* volume-knob fixes */ 2216 SND_PCI_QUIRK_VENDOR(0x10cf, "FSC", STAC_927X_VOLKNOB), 2217 {} /* terminator */ 2218 }; 2219 2220 static const unsigned int ref9205_pin_configs[12] = { 2221 0x40000100, 0x40000100, 0x01016011, 0x01014010, 2222 0x01813122, 0x01a19021, 0x01019020, 0x40000100, 2223 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030 2224 }; 2225 2226 /* 2227 STAC 9205 pin configs for 2228 102801F1 2229 102801F2 2230 102801FC 2231 102801FD 2232 10280204 2233 1028021F 2234 10280228 (Dell Vostro 1500) 2235 10280229 (Dell Vostro 1700) 2236 */ 2237 static const unsigned int dell_9205_m42_pin_configs[12] = { 2238 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310, 2239 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9, 2240 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE, 2241 }; 2242 2243 /* 2244 STAC 9205 pin configs for 2245 102801F9 2246 102801FA 2247 102801FE 2248 102801FF (Dell Precision M4300) 2249 10280206 2250 10280200 2251 10280201 2252 */ 2253 static const unsigned int dell_9205_m43_pin_configs[12] = { 2254 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310, 2255 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9, 2256 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8, 2257 }; 2258 2259 static const unsigned int dell_9205_m44_pin_configs[12] = { 2260 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310, 2261 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9, 2262 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe, 2263 }; 2264 2265 static const unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = { 2266 [STAC_9205_REF] = ref9205_pin_configs, 2267 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs, 2268 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs, 2269 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs, 2270 [STAC_9205_EAPD] = NULL, 2271 }; 2272 2273 static const char * const stac9205_models[STAC_9205_MODELS] = { 2274 [STAC_9205_AUTO] = "auto", 2275 [STAC_9205_REF] = "ref", 2276 [STAC_9205_DELL_M42] = "dell-m42", 2277 [STAC_9205_DELL_M43] = "dell-m43", 2278 [STAC_9205_DELL_M44] = "dell-m44", 2279 [STAC_9205_EAPD] = "eapd", 2280 }; 2281 2282 static const struct snd_pci_quirk stac9205_cfg_tbl[] = { 2283 /* SigmaTel reference board */ 2284 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 2285 "DFI LanParty", STAC_9205_REF), 2286 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xfb30, 2287 "SigmaTel", STAC_9205_REF), 2288 SND_PCI_QUIRK(PCI_VENDOR_ID_DFI, 0x3101, 2289 "DFI LanParty", STAC_9205_REF), 2290 /* Dell */ 2291 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1, 2292 "unknown Dell", STAC_9205_DELL_M42), 2293 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2, 2294 "unknown Dell", STAC_9205_DELL_M42), 2295 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8, 2296 "Dell Precision", STAC_9205_DELL_M43), 2297 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9, 2298 "Dell Precision", STAC_9205_DELL_M43), 2299 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa, 2300 "Dell Precision", STAC_9205_DELL_M43), 2301 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc, 2302 "unknown Dell", STAC_9205_DELL_M42), 2303 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd, 2304 "unknown Dell", STAC_9205_DELL_M42), 2305 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe, 2306 "Dell Precision", STAC_9205_DELL_M43), 2307 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff, 2308 "Dell Precision M4300", STAC_9205_DELL_M43), 2309 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204, 2310 "unknown Dell", STAC_9205_DELL_M42), 2311 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206, 2312 "Dell Precision", STAC_9205_DELL_M43), 2313 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b, 2314 "Dell Precision", STAC_9205_DELL_M43), 2315 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c, 2316 "Dell Precision", STAC_9205_DELL_M43), 2317 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f, 2318 "Dell Inspiron", STAC_9205_DELL_M44), 2319 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228, 2320 "Dell Vostro 1500", STAC_9205_DELL_M42), 2321 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0229, 2322 "Dell Vostro 1700", STAC_9205_DELL_M42), 2323 /* Gateway */ 2324 SND_PCI_QUIRK(0x107b, 0x0560, "Gateway T6834c", STAC_9205_EAPD), 2325 SND_PCI_QUIRK(0x107b, 0x0565, "Gateway T1616", STAC_9205_EAPD), 2326 {} /* terminator */ 2327 }; 2328 2329 static void stac92xx_set_config_regs(struct hda_codec *codec, 2330 const unsigned int *pincfgs) 2331 { 2332 int i; 2333 struct sigmatel_spec *spec = codec->spec; 2334 2335 if (!pincfgs) 2336 return; 2337 2338 for (i = 0; i < spec->num_pins; i++) 2339 if (spec->pin_nids[i] && pincfgs[i]) 2340 snd_hda_codec_set_pincfg(codec, spec->pin_nids[i], 2341 pincfgs[i]); 2342 } 2343 2344 /* 2345 * Analog playback callbacks 2346 */ 2347 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo, 2348 struct hda_codec *codec, 2349 struct snd_pcm_substream *substream) 2350 { 2351 struct sigmatel_spec *spec = codec->spec; 2352 if (spec->stream_delay) 2353 msleep(spec->stream_delay); 2354 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 2355 hinfo); 2356 } 2357 2358 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2359 struct hda_codec *codec, 2360 unsigned int stream_tag, 2361 unsigned int format, 2362 struct snd_pcm_substream *substream) 2363 { 2364 struct sigmatel_spec *spec = codec->spec; 2365 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream); 2366 } 2367 2368 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2369 struct hda_codec *codec, 2370 struct snd_pcm_substream *substream) 2371 { 2372 struct sigmatel_spec *spec = codec->spec; 2373 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 2374 } 2375 2376 /* 2377 * Digital playback callbacks 2378 */ 2379 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 2380 struct hda_codec *codec, 2381 struct snd_pcm_substream *substream) 2382 { 2383 struct sigmatel_spec *spec = codec->spec; 2384 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 2385 } 2386 2387 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 2388 struct hda_codec *codec, 2389 struct snd_pcm_substream *substream) 2390 { 2391 struct sigmatel_spec *spec = codec->spec; 2392 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 2393 } 2394 2395 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 2396 struct hda_codec *codec, 2397 unsigned int stream_tag, 2398 unsigned int format, 2399 struct snd_pcm_substream *substream) 2400 { 2401 struct sigmatel_spec *spec = codec->spec; 2402 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 2403 stream_tag, format, substream); 2404 } 2405 2406 static int stac92xx_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 2407 struct hda_codec *codec, 2408 struct snd_pcm_substream *substream) 2409 { 2410 struct sigmatel_spec *spec = codec->spec; 2411 return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout); 2412 } 2413 2414 2415 /* 2416 * Analog capture callbacks 2417 */ 2418 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 2419 struct hda_codec *codec, 2420 unsigned int stream_tag, 2421 unsigned int format, 2422 struct snd_pcm_substream *substream) 2423 { 2424 struct sigmatel_spec *spec = codec->spec; 2425 hda_nid_t nid = spec->adc_nids[substream->number]; 2426 2427 if (spec->powerdown_adcs) { 2428 msleep(40); 2429 snd_hda_codec_write(codec, nid, 0, 2430 AC_VERB_SET_POWER_STATE, AC_PWRST_D0); 2431 } 2432 snd_hda_codec_setup_stream(codec, nid, stream_tag, 0, format); 2433 return 0; 2434 } 2435 2436 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 2437 struct hda_codec *codec, 2438 struct snd_pcm_substream *substream) 2439 { 2440 struct sigmatel_spec *spec = codec->spec; 2441 hda_nid_t nid = spec->adc_nids[substream->number]; 2442 2443 snd_hda_codec_cleanup_stream(codec, nid); 2444 if (spec->powerdown_adcs) 2445 snd_hda_codec_write(codec, nid, 0, 2446 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 2447 return 0; 2448 } 2449 2450 static const struct hda_pcm_stream stac92xx_pcm_digital_playback = { 2451 .substreams = 1, 2452 .channels_min = 2, 2453 .channels_max = 2, 2454 /* NID is set in stac92xx_build_pcms */ 2455 .ops = { 2456 .open = stac92xx_dig_playback_pcm_open, 2457 .close = stac92xx_dig_playback_pcm_close, 2458 .prepare = stac92xx_dig_playback_pcm_prepare, 2459 .cleanup = stac92xx_dig_playback_pcm_cleanup 2460 }, 2461 }; 2462 2463 static const struct hda_pcm_stream stac92xx_pcm_digital_capture = { 2464 .substreams = 1, 2465 .channels_min = 2, 2466 .channels_max = 2, 2467 /* NID is set in stac92xx_build_pcms */ 2468 }; 2469 2470 static const struct hda_pcm_stream stac92xx_pcm_analog_playback = { 2471 .substreams = 1, 2472 .channels_min = 2, 2473 .channels_max = 8, 2474 .nid = 0x02, /* NID to query formats and rates */ 2475 .ops = { 2476 .open = stac92xx_playback_pcm_open, 2477 .prepare = stac92xx_playback_pcm_prepare, 2478 .cleanup = stac92xx_playback_pcm_cleanup 2479 }, 2480 }; 2481 2482 static const struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = { 2483 .substreams = 1, 2484 .channels_min = 2, 2485 .channels_max = 2, 2486 .nid = 0x06, /* NID to query formats and rates */ 2487 .ops = { 2488 .open = stac92xx_playback_pcm_open, 2489 .prepare = stac92xx_playback_pcm_prepare, 2490 .cleanup = stac92xx_playback_pcm_cleanup 2491 }, 2492 }; 2493 2494 static const struct hda_pcm_stream stac92xx_pcm_analog_capture = { 2495 .channels_min = 2, 2496 .channels_max = 2, 2497 /* NID + .substreams is set in stac92xx_build_pcms */ 2498 .ops = { 2499 .prepare = stac92xx_capture_pcm_prepare, 2500 .cleanup = stac92xx_capture_pcm_cleanup 2501 }, 2502 }; 2503 2504 static int stac92xx_build_pcms(struct hda_codec *codec) 2505 { 2506 struct sigmatel_spec *spec = codec->spec; 2507 struct hda_pcm *info = spec->pcm_rec; 2508 2509 codec->num_pcms = 1; 2510 codec->pcm_info = info; 2511 2512 info->name = "STAC92xx Analog"; 2513 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback; 2514 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 2515 spec->multiout.dac_nids[0]; 2516 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture; 2517 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2518 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs; 2519 2520 if (spec->alt_switch) { 2521 codec->num_pcms++; 2522 info++; 2523 info->name = "STAC92xx Analog Alt"; 2524 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback; 2525 } 2526 2527 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2528 codec->num_pcms++; 2529 info++; 2530 info->name = "STAC92xx Digital"; 2531 info->pcm_type = spec->autocfg.dig_out_type[0]; 2532 if (spec->multiout.dig_out_nid) { 2533 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback; 2534 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2535 } 2536 if (spec->dig_in_nid) { 2537 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture; 2538 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2539 } 2540 } 2541 2542 return 0; 2543 } 2544 2545 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) 2546 2547 { 2548 snd_hda_set_pin_ctl_cache(codec, nid, pin_type); 2549 } 2550 2551 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info 2552 2553 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol, 2554 struct snd_ctl_elem_value *ucontrol) 2555 { 2556 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2557 struct sigmatel_spec *spec = codec->spec; 2558 2559 ucontrol->value.integer.value[0] = !!spec->hp_switch; 2560 return 0; 2561 } 2562 2563 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid); 2564 2565 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol, 2566 struct snd_ctl_elem_value *ucontrol) 2567 { 2568 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2569 struct sigmatel_spec *spec = codec->spec; 2570 int nid = kcontrol->private_value; 2571 2572 spec->hp_switch = ucontrol->value.integer.value[0] ? nid : 0; 2573 2574 /* check to be sure that the ports are up to date with 2575 * switch changes 2576 */ 2577 stac_issue_unsol_event(codec, nid); 2578 2579 return 1; 2580 } 2581 2582 static int stac92xx_dc_bias_info(struct snd_kcontrol *kcontrol, 2583 struct snd_ctl_elem_info *uinfo) 2584 { 2585 int i; 2586 static const char * const texts[] = { 2587 "Mic In", "Line In", "Line Out" 2588 }; 2589 2590 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2591 struct sigmatel_spec *spec = codec->spec; 2592 hda_nid_t nid = kcontrol->private_value; 2593 2594 if (nid == spec->mic_switch || nid == spec->line_switch) 2595 i = 3; 2596 else 2597 i = 2; 2598 2599 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2600 uinfo->value.enumerated.items = i; 2601 uinfo->count = 1; 2602 if (uinfo->value.enumerated.item >= i) 2603 uinfo->value.enumerated.item = i-1; 2604 strcpy(uinfo->value.enumerated.name, 2605 texts[uinfo->value.enumerated.item]); 2606 2607 return 0; 2608 } 2609 2610 static int stac92xx_dc_bias_get(struct snd_kcontrol *kcontrol, 2611 struct snd_ctl_elem_value *ucontrol) 2612 { 2613 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2614 hda_nid_t nid = kcontrol->private_value; 2615 unsigned int vref = stac92xx_vref_get(codec, nid); 2616 2617 if (vref == snd_hda_get_default_vref(codec, nid)) 2618 ucontrol->value.enumerated.item[0] = 0; 2619 else if (vref == AC_PINCTL_VREF_GRD) 2620 ucontrol->value.enumerated.item[0] = 1; 2621 else if (vref == AC_PINCTL_VREF_HIZ) 2622 ucontrol->value.enumerated.item[0] = 2; 2623 2624 return 0; 2625 } 2626 2627 static int stac92xx_dc_bias_put(struct snd_kcontrol *kcontrol, 2628 struct snd_ctl_elem_value *ucontrol) 2629 { 2630 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2631 unsigned int new_vref = 0; 2632 int error; 2633 hda_nid_t nid = kcontrol->private_value; 2634 2635 if (ucontrol->value.enumerated.item[0] == 0) 2636 new_vref = snd_hda_get_default_vref(codec, nid); 2637 else if (ucontrol->value.enumerated.item[0] == 1) 2638 new_vref = AC_PINCTL_VREF_GRD; 2639 else if (ucontrol->value.enumerated.item[0] == 2) 2640 new_vref = AC_PINCTL_VREF_HIZ; 2641 else 2642 return 0; 2643 2644 if (new_vref != stac92xx_vref_get(codec, nid)) { 2645 error = stac92xx_vref_set(codec, nid, new_vref); 2646 return error; 2647 } 2648 2649 return 0; 2650 } 2651 2652 static int stac92xx_io_switch_info(struct snd_kcontrol *kcontrol, 2653 struct snd_ctl_elem_info *uinfo) 2654 { 2655 char *texts[2]; 2656 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2657 struct sigmatel_spec *spec = codec->spec; 2658 2659 if (kcontrol->private_value == spec->line_switch) 2660 texts[0] = "Line In"; 2661 else 2662 texts[0] = "Mic In"; 2663 texts[1] = "Line Out"; 2664 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED; 2665 uinfo->value.enumerated.items = 2; 2666 uinfo->count = 1; 2667 2668 if (uinfo->value.enumerated.item >= 2) 2669 uinfo->value.enumerated.item = 1; 2670 strcpy(uinfo->value.enumerated.name, 2671 texts[uinfo->value.enumerated.item]); 2672 2673 return 0; 2674 } 2675 2676 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2677 { 2678 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2679 struct sigmatel_spec *spec = codec->spec; 2680 hda_nid_t nid = kcontrol->private_value; 2681 int io_idx = (nid == spec->mic_switch) ? 1 : 0; 2682 2683 ucontrol->value.enumerated.item[0] = spec->io_switch[io_idx]; 2684 return 0; 2685 } 2686 2687 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2688 { 2689 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2690 struct sigmatel_spec *spec = codec->spec; 2691 hda_nid_t nid = kcontrol->private_value; 2692 int io_idx = (nid == spec->mic_switch) ? 1 : 0; 2693 unsigned short val = !!ucontrol->value.enumerated.item[0]; 2694 2695 spec->io_switch[io_idx] = val; 2696 2697 if (val) 2698 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 2699 else { 2700 unsigned int pinctl = AC_PINCTL_IN_EN; 2701 if (io_idx) /* set VREF for mic */ 2702 pinctl |= snd_hda_get_default_vref(codec, nid); 2703 stac92xx_auto_set_pinctl(codec, nid, pinctl); 2704 } 2705 2706 /* check the auto-mute again: we need to mute/unmute the speaker 2707 * appropriately according to the pin direction 2708 */ 2709 if (spec->hp_detect) 2710 stac_issue_unsol_event(codec, nid); 2711 2712 return 1; 2713 } 2714 2715 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info 2716 2717 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol, 2718 struct snd_ctl_elem_value *ucontrol) 2719 { 2720 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2721 struct sigmatel_spec *spec = codec->spec; 2722 2723 ucontrol->value.integer.value[0] = spec->clfe_swap; 2724 return 0; 2725 } 2726 2727 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol, 2728 struct snd_ctl_elem_value *ucontrol) 2729 { 2730 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2731 struct sigmatel_spec *spec = codec->spec; 2732 hda_nid_t nid = kcontrol->private_value & 0xff; 2733 unsigned int val = !!ucontrol->value.integer.value[0]; 2734 2735 if (spec->clfe_swap == val) 2736 return 0; 2737 2738 spec->clfe_swap = val; 2739 2740 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 2741 spec->clfe_swap ? 0x4 : 0x0); 2742 2743 return 1; 2744 } 2745 2746 #define STAC_CODEC_HP_SWITCH(xname) \ 2747 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2748 .name = xname, \ 2749 .index = 0, \ 2750 .info = stac92xx_hp_switch_info, \ 2751 .get = stac92xx_hp_switch_get, \ 2752 .put = stac92xx_hp_switch_put, \ 2753 } 2754 2755 #define STAC_CODEC_IO_SWITCH(xname, xpval) \ 2756 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2757 .name = xname, \ 2758 .index = 0, \ 2759 .info = stac92xx_io_switch_info, \ 2760 .get = stac92xx_io_switch_get, \ 2761 .put = stac92xx_io_switch_put, \ 2762 .private_value = xpval, \ 2763 } 2764 2765 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \ 2766 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2767 .name = xname, \ 2768 .index = 0, \ 2769 .info = stac92xx_clfe_switch_info, \ 2770 .get = stac92xx_clfe_switch_get, \ 2771 .put = stac92xx_clfe_switch_put, \ 2772 .private_value = xpval, \ 2773 } 2774 2775 enum { 2776 STAC_CTL_WIDGET_VOL, 2777 STAC_CTL_WIDGET_MUTE, 2778 STAC_CTL_WIDGET_MUTE_BEEP, 2779 STAC_CTL_WIDGET_MONO_MUX, 2780 STAC_CTL_WIDGET_HP_SWITCH, 2781 STAC_CTL_WIDGET_IO_SWITCH, 2782 STAC_CTL_WIDGET_CLFE_SWITCH, 2783 STAC_CTL_WIDGET_DC_BIAS 2784 }; 2785 2786 static const struct snd_kcontrol_new stac92xx_control_templates[] = { 2787 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2788 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2789 HDA_CODEC_MUTE_BEEP(NULL, 0, 0, 0), 2790 STAC_MONO_MUX, 2791 STAC_CODEC_HP_SWITCH(NULL), 2792 STAC_CODEC_IO_SWITCH(NULL, 0), 2793 STAC_CODEC_CLFE_SWITCH(NULL, 0), 2794 DC_BIAS(NULL, 0, 0), 2795 }; 2796 2797 /* add dynamic controls */ 2798 static struct snd_kcontrol_new * 2799 stac_control_new(struct sigmatel_spec *spec, 2800 const struct snd_kcontrol_new *ktemp, 2801 const char *name, 2802 unsigned int subdev) 2803 { 2804 struct snd_kcontrol_new *knew; 2805 2806 snd_array_init(&spec->kctls, sizeof(*knew), 32); 2807 knew = snd_array_new(&spec->kctls); 2808 if (!knew) 2809 return NULL; 2810 *knew = *ktemp; 2811 knew->name = kstrdup(name, GFP_KERNEL); 2812 if (!knew->name) { 2813 /* roolback */ 2814 memset(knew, 0, sizeof(*knew)); 2815 spec->kctls.alloced--; 2816 return NULL; 2817 } 2818 knew->subdevice = subdev; 2819 return knew; 2820 } 2821 2822 static struct snd_kcontrol_new * 2823 add_control_temp(struct sigmatel_spec *spec, 2824 const struct snd_kcontrol_new *ktemp, 2825 int idx, const char *name, 2826 unsigned long val) 2827 { 2828 struct snd_kcontrol_new *knew = stac_control_new(spec, ktemp, name, 2829 HDA_SUBDEV_AMP_FLAG); 2830 if (!knew) 2831 return NULL; 2832 knew->index = idx; 2833 knew->private_value = val; 2834 return knew; 2835 } 2836 2837 static int stac92xx_add_control_temp(struct sigmatel_spec *spec, 2838 const struct snd_kcontrol_new *ktemp, 2839 int idx, const char *name, 2840 unsigned long val) 2841 { 2842 return add_control_temp(spec, ktemp, idx, name, val) ? 0 : -ENOMEM; 2843 } 2844 2845 static inline int stac92xx_add_control_idx(struct sigmatel_spec *spec, 2846 int type, int idx, const char *name, 2847 unsigned long val) 2848 { 2849 return stac92xx_add_control_temp(spec, 2850 &stac92xx_control_templates[type], 2851 idx, name, val); 2852 } 2853 2854 2855 /* add dynamic controls */ 2856 static inline int stac92xx_add_control(struct sigmatel_spec *spec, int type, 2857 const char *name, unsigned long val) 2858 { 2859 return stac92xx_add_control_idx(spec, type, 0, name, val); 2860 } 2861 2862 static const struct snd_kcontrol_new stac_input_src_temp = { 2863 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 2864 .name = "Input Source", 2865 .info = stac92xx_mux_enum_info, 2866 .get = stac92xx_mux_enum_get, 2867 .put = stac92xx_mux_enum_put, 2868 }; 2869 2870 static inline int stac92xx_add_jack_mode_control(struct hda_codec *codec, 2871 hda_nid_t nid, int idx) 2872 { 2873 int def_conf = snd_hda_codec_get_pincfg(codec, nid); 2874 int control = 0; 2875 struct sigmatel_spec *spec = codec->spec; 2876 char name[22]; 2877 2878 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { 2879 if (spec->headset_jack && snd_hda_get_input_pin_attr(def_conf) 2880 != INPUT_PIN_ATTR_DOCK) 2881 return 0; 2882 if (snd_hda_get_default_vref(codec, nid) == AC_PINCTL_VREF_GRD 2883 && nid == spec->line_switch) 2884 control = STAC_CTL_WIDGET_IO_SWITCH; 2885 else if (snd_hda_query_pin_caps(codec, nid) 2886 & (AC_PINCAP_VREF_GRD << AC_PINCAP_VREF_SHIFT)) 2887 control = STAC_CTL_WIDGET_DC_BIAS; 2888 else if (nid == spec->mic_switch) 2889 control = STAC_CTL_WIDGET_IO_SWITCH; 2890 } 2891 2892 if (control) { 2893 snd_hda_get_pin_label(codec, nid, &spec->autocfg, 2894 name, sizeof(name), NULL); 2895 return stac92xx_add_control(codec->spec, control, 2896 strcat(name, " Jack Mode"), nid); 2897 } 2898 2899 return 0; 2900 } 2901 2902 static int stac92xx_add_input_source(struct sigmatel_spec *spec) 2903 { 2904 struct snd_kcontrol_new *knew; 2905 struct hda_input_mux *imux = &spec->private_imux; 2906 2907 if (spec->auto_mic) 2908 return 0; /* no need for input source */ 2909 if (!spec->num_adcs || imux->num_items <= 1) 2910 return 0; /* no need for input source control */ 2911 knew = stac_control_new(spec, &stac_input_src_temp, 2912 stac_input_src_temp.name, 0); 2913 if (!knew) 2914 return -ENOMEM; 2915 knew->count = spec->num_adcs; 2916 return 0; 2917 } 2918 2919 /* check whether the line-input can be used as line-out */ 2920 static hda_nid_t check_line_out_switch(struct hda_codec *codec) 2921 { 2922 struct sigmatel_spec *spec = codec->spec; 2923 struct auto_pin_cfg *cfg = &spec->autocfg; 2924 hda_nid_t nid; 2925 unsigned int pincap; 2926 int i; 2927 2928 if (cfg->line_out_type != AUTO_PIN_LINE_OUT) 2929 return 0; 2930 for (i = 0; i < cfg->num_inputs; i++) { 2931 if (cfg->inputs[i].type == AUTO_PIN_LINE_IN) { 2932 nid = cfg->inputs[i].pin; 2933 pincap = snd_hda_query_pin_caps(codec, nid); 2934 if (pincap & AC_PINCAP_OUT) 2935 return nid; 2936 } 2937 } 2938 return 0; 2939 } 2940 2941 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid); 2942 2943 /* check whether the mic-input can be used as line-out */ 2944 static hda_nid_t check_mic_out_switch(struct hda_codec *codec, hda_nid_t *dac) 2945 { 2946 struct sigmatel_spec *spec = codec->spec; 2947 struct auto_pin_cfg *cfg = &spec->autocfg; 2948 unsigned int def_conf, pincap; 2949 int i; 2950 2951 *dac = 0; 2952 if (cfg->line_out_type != AUTO_PIN_LINE_OUT) 2953 return 0; 2954 for (i = 0; i < cfg->num_inputs; i++) { 2955 hda_nid_t nid = cfg->inputs[i].pin; 2956 if (cfg->inputs[i].type != AUTO_PIN_MIC) 2957 continue; 2958 def_conf = snd_hda_codec_get_pincfg(codec, nid); 2959 /* some laptops have an internal analog microphone 2960 * which can't be used as a output */ 2961 if (snd_hda_get_input_pin_attr(def_conf) != INPUT_PIN_ATTR_INT) { 2962 pincap = snd_hda_query_pin_caps(codec, nid); 2963 if (pincap & AC_PINCAP_OUT) { 2964 *dac = get_unassigned_dac(codec, nid); 2965 if (*dac) 2966 return nid; 2967 } 2968 } 2969 } 2970 return 0; 2971 } 2972 2973 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2974 { 2975 int i; 2976 2977 for (i = 0; i < spec->multiout.num_dacs; i++) { 2978 if (spec->multiout.dac_nids[i] == nid) 2979 return 1; 2980 } 2981 2982 return 0; 2983 } 2984 2985 static int check_all_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2986 { 2987 int i; 2988 if (is_in_dac_nids(spec, nid)) 2989 return 1; 2990 for (i = 0; i < spec->autocfg.hp_outs; i++) 2991 if (spec->hp_dacs[i] == nid) 2992 return 1; 2993 for (i = 0; i < spec->autocfg.speaker_outs; i++) 2994 if (spec->speaker_dacs[i] == nid) 2995 return 1; 2996 return 0; 2997 } 2998 2999 static hda_nid_t get_unassigned_dac(struct hda_codec *codec, hda_nid_t nid) 3000 { 3001 struct sigmatel_spec *spec = codec->spec; 3002 struct auto_pin_cfg *cfg = &spec->autocfg; 3003 int j, conn_len; 3004 hda_nid_t conn[HDA_MAX_CONNECTIONS], fallback_dac; 3005 unsigned int wcaps, wtype; 3006 3007 conn_len = snd_hda_get_connections(codec, nid, conn, 3008 HDA_MAX_CONNECTIONS); 3009 /* 92HD88: trace back up the link of nids to find the DAC */ 3010 while (conn_len == 1 && (get_wcaps_type(get_wcaps(codec, conn[0])) 3011 != AC_WID_AUD_OUT)) { 3012 nid = conn[0]; 3013 conn_len = snd_hda_get_connections(codec, nid, conn, 3014 HDA_MAX_CONNECTIONS); 3015 } 3016 for (j = 0; j < conn_len; j++) { 3017 wcaps = get_wcaps(codec, conn[j]); 3018 wtype = get_wcaps_type(wcaps); 3019 /* we check only analog outputs */ 3020 if (wtype != AC_WID_AUD_OUT || (wcaps & AC_WCAP_DIGITAL)) 3021 continue; 3022 /* if this route has a free DAC, assign it */ 3023 if (!check_all_dac_nids(spec, conn[j])) { 3024 if (conn_len > 1) { 3025 /* select this DAC in the pin's input mux */ 3026 snd_hda_codec_write_cache(codec, nid, 0, 3027 AC_VERB_SET_CONNECT_SEL, j); 3028 } 3029 return conn[j]; 3030 } 3031 } 3032 3033 /* if all DACs are already assigned, connect to the primary DAC, 3034 unless we're assigning a secondary headphone */ 3035 fallback_dac = spec->multiout.dac_nids[0]; 3036 if (spec->multiout.hp_nid) { 3037 for (j = 0; j < cfg->hp_outs; j++) 3038 if (cfg->hp_pins[j] == nid) { 3039 fallback_dac = spec->multiout.hp_nid; 3040 break; 3041 } 3042 } 3043 3044 if (conn_len > 1) { 3045 for (j = 0; j < conn_len; j++) { 3046 if (conn[j] == fallback_dac) { 3047 snd_hda_codec_write_cache(codec, nid, 0, 3048 AC_VERB_SET_CONNECT_SEL, j); 3049 break; 3050 } 3051 } 3052 } 3053 return 0; 3054 } 3055 3056 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid); 3057 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid); 3058 3059 /* 3060 * Fill in the dac_nids table from the parsed pin configuration 3061 * This function only works when every pin in line_out_pins[] 3062 * contains atleast one DAC in its connection list. Some 92xx 3063 * codecs are not connected directly to a DAC, such as the 9200 3064 * and 9202/925x. For those, dac_nids[] must be hard-coded. 3065 */ 3066 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec) 3067 { 3068 struct sigmatel_spec *spec = codec->spec; 3069 struct auto_pin_cfg *cfg = &spec->autocfg; 3070 int i; 3071 hda_nid_t nid, dac; 3072 3073 for (i = 0; i < cfg->line_outs; i++) { 3074 nid = cfg->line_out_pins[i]; 3075 dac = get_unassigned_dac(codec, nid); 3076 if (!dac) { 3077 if (spec->multiout.num_dacs > 0) { 3078 /* we have already working output pins, 3079 * so let's drop the broken ones again 3080 */ 3081 cfg->line_outs = spec->multiout.num_dacs; 3082 break; 3083 } 3084 /* error out, no available DAC found */ 3085 snd_printk(KERN_ERR 3086 "%s: No available DAC for pin 0x%x\n", 3087 __func__, nid); 3088 return -ENODEV; 3089 } 3090 add_spec_dacs(spec, dac); 3091 } 3092 3093 for (i = 0; i < cfg->hp_outs; i++) { 3094 nid = cfg->hp_pins[i]; 3095 dac = get_unassigned_dac(codec, nid); 3096 if (dac) { 3097 if (!spec->multiout.hp_nid) 3098 spec->multiout.hp_nid = dac; 3099 else 3100 add_spec_extra_dacs(spec, dac); 3101 } 3102 spec->hp_dacs[i] = dac; 3103 } 3104 3105 for (i = 0; i < cfg->speaker_outs; i++) { 3106 nid = cfg->speaker_pins[i]; 3107 dac = get_unassigned_dac(codec, nid); 3108 if (dac) 3109 add_spec_extra_dacs(spec, dac); 3110 spec->speaker_dacs[i] = dac; 3111 } 3112 3113 /* add line-in as output */ 3114 nid = check_line_out_switch(codec); 3115 if (nid) { 3116 dac = get_unassigned_dac(codec, nid); 3117 if (dac) { 3118 snd_printdd("STAC: Add line-in 0x%x as output %d\n", 3119 nid, cfg->line_outs); 3120 cfg->line_out_pins[cfg->line_outs] = nid; 3121 cfg->line_outs++; 3122 spec->line_switch = nid; 3123 add_spec_dacs(spec, dac); 3124 } 3125 } 3126 /* add mic as output */ 3127 nid = check_mic_out_switch(codec, &dac); 3128 if (nid && dac) { 3129 snd_printdd("STAC: Add mic-in 0x%x as output %d\n", 3130 nid, cfg->line_outs); 3131 cfg->line_out_pins[cfg->line_outs] = nid; 3132 cfg->line_outs++; 3133 spec->mic_switch = nid; 3134 add_spec_dacs(spec, dac); 3135 } 3136 3137 snd_printd("stac92xx: dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 3138 spec->multiout.num_dacs, 3139 spec->multiout.dac_nids[0], 3140 spec->multiout.dac_nids[1], 3141 spec->multiout.dac_nids[2], 3142 spec->multiout.dac_nids[3], 3143 spec->multiout.dac_nids[4]); 3144 3145 return 0; 3146 } 3147 3148 /* create volume control/switch for the given prefx type */ 3149 static int create_controls_idx(struct hda_codec *codec, const char *pfx, 3150 int idx, hda_nid_t nid, int chs) 3151 { 3152 struct sigmatel_spec *spec = codec->spec; 3153 char name[32]; 3154 int err; 3155 3156 if (!spec->check_volume_offset) { 3157 unsigned int caps, step, nums, db_scale; 3158 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3159 step = (caps & AC_AMPCAP_STEP_SIZE) >> 3160 AC_AMPCAP_STEP_SIZE_SHIFT; 3161 step = (step + 1) * 25; /* in .01dB unit */ 3162 nums = (caps & AC_AMPCAP_NUM_STEPS) >> 3163 AC_AMPCAP_NUM_STEPS_SHIFT; 3164 db_scale = nums * step; 3165 /* if dB scale is over -64dB, and finer enough, 3166 * let's reduce it to half 3167 */ 3168 if (db_scale > 6400 && nums >= 0x1f) 3169 spec->volume_offset = nums / 2; 3170 spec->check_volume_offset = 1; 3171 } 3172 3173 sprintf(name, "%s Playback Volume", pfx); 3174 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, idx, name, 3175 HDA_COMPOSE_AMP_VAL_OFS(nid, chs, 0, HDA_OUTPUT, 3176 spec->volume_offset)); 3177 if (err < 0) 3178 return err; 3179 sprintf(name, "%s Playback Switch", pfx); 3180 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_MUTE, idx, name, 3181 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 3182 if (err < 0) 3183 return err; 3184 return 0; 3185 } 3186 3187 #define create_controls(codec, pfx, nid, chs) \ 3188 create_controls_idx(codec, pfx, 0, nid, chs) 3189 3190 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid) 3191 { 3192 if (spec->multiout.num_dacs > 4) { 3193 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid); 3194 return 1; 3195 } else { 3196 snd_BUG_ON(spec->multiout.dac_nids != spec->dac_nids); 3197 spec->dac_nids[spec->multiout.num_dacs] = nid; 3198 spec->multiout.num_dacs++; 3199 } 3200 return 0; 3201 } 3202 3203 static int add_spec_extra_dacs(struct sigmatel_spec *spec, hda_nid_t nid) 3204 { 3205 int i; 3206 for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) { 3207 if (!spec->multiout.extra_out_nid[i]) { 3208 spec->multiout.extra_out_nid[i] = nid; 3209 return 0; 3210 } 3211 } 3212 printk(KERN_WARNING "stac92xx: No space for extra DAC 0x%x\n", nid); 3213 return 1; 3214 } 3215 3216 /* Create output controls 3217 * The mixer elements are named depending on the given type (AUTO_PIN_XXX_OUT) 3218 */ 3219 static int create_multi_out_ctls(struct hda_codec *codec, int num_outs, 3220 const hda_nid_t *pins, 3221 const hda_nid_t *dac_nids, 3222 int type) 3223 { 3224 struct sigmatel_spec *spec = codec->spec; 3225 static const char * const chname[4] = { 3226 "Front", "Surround", NULL /*CLFE*/, "Side" 3227 }; 3228 hda_nid_t nid; 3229 int i, err; 3230 unsigned int wid_caps; 3231 3232 for (i = 0; i < num_outs && i < ARRAY_SIZE(chname); i++) { 3233 if (type == AUTO_PIN_HP_OUT && !spec->hp_detect) { 3234 if (is_jack_detectable(codec, pins[i])) 3235 spec->hp_detect = 1; 3236 } 3237 nid = dac_nids[i]; 3238 if (!nid) 3239 continue; 3240 if (type != AUTO_PIN_HP_OUT && i == 2) { 3241 /* Center/LFE */ 3242 err = create_controls(codec, "Center", nid, 1); 3243 if (err < 0) 3244 return err; 3245 err = create_controls(codec, "LFE", nid, 2); 3246 if (err < 0) 3247 return err; 3248 3249 wid_caps = get_wcaps(codec, nid); 3250 3251 if (wid_caps & AC_WCAP_LR_SWAP) { 3252 err = stac92xx_add_control(spec, 3253 STAC_CTL_WIDGET_CLFE_SWITCH, 3254 "Swap Center/LFE Playback Switch", nid); 3255 3256 if (err < 0) 3257 return err; 3258 } 3259 3260 } else { 3261 const char *name; 3262 int idx; 3263 switch (type) { 3264 case AUTO_PIN_HP_OUT: 3265 name = "Headphone"; 3266 idx = i; 3267 break; 3268 case AUTO_PIN_SPEAKER_OUT: 3269 if (num_outs <= 1) { 3270 name = "Speaker"; 3271 idx = i; 3272 break; 3273 } 3274 /* Fall through in case of multi speaker outs */ 3275 default: 3276 name = chname[i]; 3277 idx = 0; 3278 break; 3279 } 3280 err = create_controls_idx(codec, name, idx, nid, 3); 3281 if (err < 0) 3282 return err; 3283 } 3284 } 3285 return 0; 3286 } 3287 3288 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask, 3289 unsigned int dir_mask, unsigned int data); 3290 3291 /* hook for controlling mic-mute LED GPIO */ 3292 static int stac92xx_capture_sw_put_led(struct snd_kcontrol *kcontrol, 3293 struct snd_ctl_elem_value *ucontrol) 3294 { 3295 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3296 struct sigmatel_spec *spec = codec->spec; 3297 int err; 3298 bool mute; 3299 3300 err = snd_hda_mixer_amp_switch_put(kcontrol, ucontrol); 3301 if (err <= 0) 3302 return err; 3303 mute = !(ucontrol->value.integer.value[0] && 3304 ucontrol->value.integer.value[1]); 3305 if (spec->mic_mute_led_on != mute) { 3306 spec->mic_mute_led_on = mute; 3307 if (mute) 3308 spec->gpio_data |= spec->mic_mute_led_gpio; 3309 else 3310 spec->gpio_data &= ~spec->mic_mute_led_gpio; 3311 stac_gpio_set(codec, spec->gpio_mask, 3312 spec->gpio_dir, spec->gpio_data); 3313 } 3314 return err; 3315 } 3316 3317 static int stac92xx_add_capvol_ctls(struct hda_codec *codec, unsigned long vol, 3318 unsigned long sw, int idx) 3319 { 3320 struct sigmatel_spec *spec = codec->spec; 3321 struct snd_kcontrol_new *knew; 3322 int err; 3323 3324 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, 3325 "Capture Volume", vol); 3326 if (err < 0) 3327 return err; 3328 3329 knew = add_control_temp(spec, 3330 &stac92xx_control_templates[STAC_CTL_WIDGET_MUTE], 3331 idx, "Capture Switch", sw); 3332 if (!knew) 3333 return -ENOMEM; 3334 /* add a LED hook for some HP laptops */ 3335 if (spec->mic_mute_led_gpio) 3336 knew->put = stac92xx_capture_sw_put_led; 3337 3338 return 0; 3339 } 3340 3341 /* add playback controls from the parsed DAC table */ 3342 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec, 3343 const struct auto_pin_cfg *cfg) 3344 { 3345 struct sigmatel_spec *spec = codec->spec; 3346 hda_nid_t nid; 3347 int err; 3348 int idx; 3349 3350 err = create_multi_out_ctls(codec, cfg->line_outs, cfg->line_out_pins, 3351 spec->multiout.dac_nids, 3352 cfg->line_out_type); 3353 if (err < 0) 3354 return err; 3355 3356 if (cfg->hp_outs > 1 && cfg->line_out_type == AUTO_PIN_LINE_OUT) { 3357 err = stac92xx_add_control(spec, 3358 STAC_CTL_WIDGET_HP_SWITCH, 3359 "Headphone as Line Out Switch", 3360 cfg->hp_pins[cfg->hp_outs - 1]); 3361 if (err < 0) 3362 return err; 3363 } 3364 3365 for (idx = 0; idx < cfg->num_inputs; idx++) { 3366 if (cfg->inputs[idx].type > AUTO_PIN_LINE_IN) 3367 break; 3368 nid = cfg->inputs[idx].pin; 3369 err = stac92xx_add_jack_mode_control(codec, nid, idx); 3370 if (err < 0) 3371 return err; 3372 } 3373 3374 return 0; 3375 } 3376 3377 /* add playback controls for Speaker and HP outputs */ 3378 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, 3379 struct auto_pin_cfg *cfg) 3380 { 3381 struct sigmatel_spec *spec = codec->spec; 3382 int err; 3383 3384 err = create_multi_out_ctls(codec, cfg->hp_outs, cfg->hp_pins, 3385 spec->hp_dacs, AUTO_PIN_HP_OUT); 3386 if (err < 0) 3387 return err; 3388 3389 err = create_multi_out_ctls(codec, cfg->speaker_outs, cfg->speaker_pins, 3390 spec->speaker_dacs, AUTO_PIN_SPEAKER_OUT); 3391 if (err < 0) 3392 return err; 3393 3394 return 0; 3395 } 3396 3397 /* labels for mono mux outputs */ 3398 static const char * const stac92xx_mono_labels[4] = { 3399 "DAC0", "DAC1", "Mixer", "DAC2" 3400 }; 3401 3402 /* create mono mux for mono out on capable codecs */ 3403 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec) 3404 { 3405 struct sigmatel_spec *spec = codec->spec; 3406 struct hda_input_mux *mono_mux = &spec->private_mono_mux; 3407 int i, num_cons; 3408 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)]; 3409 3410 num_cons = snd_hda_get_connections(codec, 3411 spec->mono_nid, 3412 con_lst, 3413 HDA_MAX_NUM_INPUTS); 3414 if (num_cons <= 0 || num_cons > ARRAY_SIZE(stac92xx_mono_labels)) 3415 return -EINVAL; 3416 3417 for (i = 0; i < num_cons; i++) 3418 snd_hda_add_imux_item(mono_mux, stac92xx_mono_labels[i], i, 3419 NULL); 3420 3421 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX, 3422 "Mono Mux", spec->mono_nid); 3423 } 3424 3425 /* create PC beep volume controls */ 3426 static int stac92xx_auto_create_beep_ctls(struct hda_codec *codec, 3427 hda_nid_t nid) 3428 { 3429 struct sigmatel_spec *spec = codec->spec; 3430 u32 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3431 int err, type = STAC_CTL_WIDGET_MUTE_BEEP; 3432 3433 if (spec->anabeep_nid == nid) 3434 type = STAC_CTL_WIDGET_MUTE; 3435 3436 /* check for mute support for the the amp */ 3437 if ((caps & AC_AMPCAP_MUTE) >> AC_AMPCAP_MUTE_SHIFT) { 3438 err = stac92xx_add_control(spec, type, 3439 "Beep Playback Switch", 3440 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); 3441 if (err < 0) 3442 return err; 3443 } 3444 3445 /* check to see if there is volume support for the amp */ 3446 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) { 3447 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, 3448 "Beep Playback Volume", 3449 HDA_COMPOSE_AMP_VAL(nid, 1, 0, HDA_OUTPUT)); 3450 if (err < 0) 3451 return err; 3452 } 3453 return 0; 3454 } 3455 3456 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3457 #define stac92xx_dig_beep_switch_info snd_ctl_boolean_mono_info 3458 3459 static int stac92xx_dig_beep_switch_get(struct snd_kcontrol *kcontrol, 3460 struct snd_ctl_elem_value *ucontrol) 3461 { 3462 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3463 ucontrol->value.integer.value[0] = codec->beep->enabled; 3464 return 0; 3465 } 3466 3467 static int stac92xx_dig_beep_switch_put(struct snd_kcontrol *kcontrol, 3468 struct snd_ctl_elem_value *ucontrol) 3469 { 3470 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 3471 return snd_hda_enable_beep_device(codec, ucontrol->value.integer.value[0]); 3472 } 3473 3474 static const struct snd_kcontrol_new stac92xx_dig_beep_ctrl = { 3475 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 3476 .info = stac92xx_dig_beep_switch_info, 3477 .get = stac92xx_dig_beep_switch_get, 3478 .put = stac92xx_dig_beep_switch_put, 3479 }; 3480 3481 static int stac92xx_beep_switch_ctl(struct hda_codec *codec) 3482 { 3483 return stac92xx_add_control_temp(codec->spec, &stac92xx_dig_beep_ctrl, 3484 0, "Beep Playback Switch", 0); 3485 } 3486 #endif 3487 3488 static int stac92xx_auto_create_mux_input_ctls(struct hda_codec *codec) 3489 { 3490 struct sigmatel_spec *spec = codec->spec; 3491 int i, j, err = 0; 3492 3493 for (i = 0; i < spec->num_muxes; i++) { 3494 hda_nid_t nid; 3495 unsigned int wcaps; 3496 unsigned long val; 3497 3498 nid = spec->mux_nids[i]; 3499 wcaps = get_wcaps(codec, nid); 3500 if (!(wcaps & AC_WCAP_OUT_AMP)) 3501 continue; 3502 3503 /* check whether already the same control was created as 3504 * normal Capture Volume. 3505 */ 3506 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT); 3507 for (j = 0; j < spec->num_caps; j++) { 3508 if (spec->capvols[j] == val) 3509 break; 3510 } 3511 if (j < spec->num_caps) 3512 continue; 3513 3514 err = stac92xx_add_control_idx(spec, STAC_CTL_WIDGET_VOL, i, 3515 "Mux Capture Volume", val); 3516 if (err < 0) 3517 return err; 3518 } 3519 return 0; 3520 }; 3521 3522 static const char * const stac92xx_spdif_labels[3] = { 3523 "Digital Playback", "Analog Mux 1", "Analog Mux 2", 3524 }; 3525 3526 static int stac92xx_auto_create_spdif_mux_ctls(struct hda_codec *codec) 3527 { 3528 struct sigmatel_spec *spec = codec->spec; 3529 struct hda_input_mux *spdif_mux = &spec->private_smux; 3530 const char * const *labels = spec->spdif_labels; 3531 int i, num_cons; 3532 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; 3533 3534 num_cons = snd_hda_get_connections(codec, 3535 spec->smux_nids[0], 3536 con_lst, 3537 HDA_MAX_NUM_INPUTS); 3538 if (num_cons <= 0) 3539 return -EINVAL; 3540 3541 if (!labels) 3542 labels = stac92xx_spdif_labels; 3543 3544 for (i = 0; i < num_cons; i++) 3545 snd_hda_add_imux_item(spdif_mux, labels[i], i, NULL); 3546 3547 return 0; 3548 } 3549 3550 /* labels for dmic mux inputs */ 3551 static const char * const stac92xx_dmic_labels[5] = { 3552 "Analog Inputs", "Digital Mic 1", "Digital Mic 2", 3553 "Digital Mic 3", "Digital Mic 4" 3554 }; 3555 3556 static hda_nid_t get_connected_node(struct hda_codec *codec, hda_nid_t mux, 3557 int idx) 3558 { 3559 hda_nid_t conn[HDA_MAX_NUM_INPUTS]; 3560 int nums; 3561 nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn)); 3562 if (idx >= 0 && idx < nums) 3563 return conn[idx]; 3564 return 0; 3565 } 3566 3567 /* look for NID recursively */ 3568 #define get_connection_index(codec, mux, nid) \ 3569 snd_hda_get_conn_index(codec, mux, nid, 1) 3570 3571 /* create a volume assigned to the given pin (only if supported) */ 3572 /* return 1 if the volume control is created */ 3573 static int create_elem_capture_vol(struct hda_codec *codec, hda_nid_t nid, 3574 const char *label, int idx, int direction) 3575 { 3576 unsigned int caps, nums; 3577 char name[32]; 3578 int err; 3579 3580 if (direction == HDA_OUTPUT) 3581 caps = AC_WCAP_OUT_AMP; 3582 else 3583 caps = AC_WCAP_IN_AMP; 3584 if (!(get_wcaps(codec, nid) & caps)) 3585 return 0; 3586 caps = query_amp_caps(codec, nid, direction); 3587 nums = (caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT; 3588 if (!nums) 3589 return 0; 3590 snprintf(name, sizeof(name), "%s Capture Volume", label); 3591 err = stac92xx_add_control_idx(codec->spec, STAC_CTL_WIDGET_VOL, idx, name, 3592 HDA_COMPOSE_AMP_VAL(nid, 3, 0, direction)); 3593 if (err < 0) 3594 return err; 3595 return 1; 3596 } 3597 3598 /* create playback/capture controls for input pins on dmic capable codecs */ 3599 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, 3600 const struct auto_pin_cfg *cfg) 3601 { 3602 struct sigmatel_spec *spec = codec->spec; 3603 struct hda_input_mux *imux = &spec->private_imux; 3604 struct hda_input_mux *dimux = &spec->private_dimux; 3605 int err, i; 3606 unsigned int def_conf; 3607 3608 snd_hda_add_imux_item(dimux, stac92xx_dmic_labels[0], 0, NULL); 3609 3610 for (i = 0; i < spec->num_dmics; i++) { 3611 hda_nid_t nid; 3612 int index, type_idx; 3613 char label[32]; 3614 3615 nid = spec->dmic_nids[i]; 3616 if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN) 3617 continue; 3618 def_conf = snd_hda_codec_get_pincfg(codec, nid); 3619 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 3620 continue; 3621 3622 index = get_connection_index(codec, spec->dmux_nids[0], nid); 3623 if (index < 0) 3624 continue; 3625 3626 snd_hda_get_pin_label(codec, nid, &spec->autocfg, 3627 label, sizeof(label), NULL); 3628 snd_hda_add_imux_item(dimux, label, index, &type_idx); 3629 if (snd_hda_get_bool_hint(codec, "separate_dmux") != 1) 3630 snd_hda_add_imux_item(imux, label, index, &type_idx); 3631 3632 err = create_elem_capture_vol(codec, nid, label, type_idx, 3633 HDA_INPUT); 3634 if (err < 0) 3635 return err; 3636 if (!err) { 3637 err = create_elem_capture_vol(codec, nid, label, 3638 type_idx, HDA_OUTPUT); 3639 if (err < 0) 3640 return err; 3641 if (!err) { 3642 nid = get_connected_node(codec, 3643 spec->dmux_nids[0], index); 3644 if (nid) 3645 err = create_elem_capture_vol(codec, 3646 nid, label, 3647 type_idx, HDA_INPUT); 3648 if (err < 0) 3649 return err; 3650 } 3651 } 3652 } 3653 3654 return 0; 3655 } 3656 3657 static int check_mic_pin(struct hda_codec *codec, hda_nid_t nid, 3658 hda_nid_t *fixed, hda_nid_t *ext, hda_nid_t *dock) 3659 { 3660 unsigned int cfg; 3661 unsigned int type; 3662 3663 if (!nid) 3664 return 0; 3665 cfg = snd_hda_codec_get_pincfg(codec, nid); 3666 type = get_defcfg_device(cfg); 3667 switch (snd_hda_get_input_pin_attr(cfg)) { 3668 case INPUT_PIN_ATTR_INT: 3669 if (*fixed) 3670 return 1; /* already occupied */ 3671 if (type != AC_JACK_MIC_IN) 3672 return 1; /* invalid type */ 3673 *fixed = nid; 3674 break; 3675 case INPUT_PIN_ATTR_UNUSED: 3676 break; 3677 case INPUT_PIN_ATTR_DOCK: 3678 if (*dock) 3679 return 1; /* already occupied */ 3680 if (type != AC_JACK_MIC_IN && type != AC_JACK_LINE_IN) 3681 return 1; /* invalid type */ 3682 *dock = nid; 3683 break; 3684 default: 3685 if (*ext) 3686 return 1; /* already occupied */ 3687 if (type != AC_JACK_MIC_IN) 3688 return 1; /* invalid type */ 3689 *ext = nid; 3690 break; 3691 } 3692 return 0; 3693 } 3694 3695 static int set_mic_route(struct hda_codec *codec, 3696 struct sigmatel_mic_route *mic, 3697 hda_nid_t pin) 3698 { 3699 struct sigmatel_spec *spec = codec->spec; 3700 struct auto_pin_cfg *cfg = &spec->autocfg; 3701 int i; 3702 3703 mic->pin = pin; 3704 if (pin == 0) 3705 return 0; 3706 for (i = 0; i < cfg->num_inputs; i++) { 3707 if (pin == cfg->inputs[i].pin) 3708 break; 3709 } 3710 if (i < cfg->num_inputs && cfg->inputs[i].type == AUTO_PIN_MIC) { 3711 /* analog pin */ 3712 i = get_connection_index(codec, spec->mux_nids[0], pin); 3713 if (i < 0) 3714 return -1; 3715 mic->mux_idx = i; 3716 mic->dmux_idx = -1; 3717 if (spec->dmux_nids) 3718 mic->dmux_idx = get_connection_index(codec, 3719 spec->dmux_nids[0], 3720 spec->mux_nids[0]); 3721 } else if (spec->dmux_nids) { 3722 /* digital pin */ 3723 i = get_connection_index(codec, spec->dmux_nids[0], pin); 3724 if (i < 0) 3725 return -1; 3726 mic->dmux_idx = i; 3727 mic->mux_idx = -1; 3728 if (spec->mux_nids) 3729 mic->mux_idx = get_connection_index(codec, 3730 spec->mux_nids[0], 3731 spec->dmux_nids[0]); 3732 } 3733 return 0; 3734 } 3735 3736 /* return non-zero if the device is for automatic mic switch */ 3737 static int stac_check_auto_mic(struct hda_codec *codec) 3738 { 3739 struct sigmatel_spec *spec = codec->spec; 3740 struct auto_pin_cfg *cfg = &spec->autocfg; 3741 hda_nid_t fixed, ext, dock; 3742 int i; 3743 3744 fixed = ext = dock = 0; 3745 for (i = 0; i < cfg->num_inputs; i++) 3746 if (check_mic_pin(codec, cfg->inputs[i].pin, 3747 &fixed, &ext, &dock)) 3748 return 0; 3749 for (i = 0; i < spec->num_dmics; i++) 3750 if (check_mic_pin(codec, spec->dmic_nids[i], 3751 &fixed, &ext, &dock)) 3752 return 0; 3753 if (!fixed || (!ext && !dock)) 3754 return 0; /* no input to switch */ 3755 if (!is_jack_detectable(codec, ext)) 3756 return 0; /* no unsol support */ 3757 if (set_mic_route(codec, &spec->ext_mic, ext) || 3758 set_mic_route(codec, &spec->int_mic, fixed) || 3759 set_mic_route(codec, &spec->dock_mic, dock)) 3760 return 0; /* something is wrong */ 3761 return 1; 3762 } 3763 3764 /* create playback/capture controls for input pins */ 3765 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) 3766 { 3767 struct sigmatel_spec *spec = codec->spec; 3768 struct hda_input_mux *imux = &spec->private_imux; 3769 int i, j; 3770 const char *label; 3771 3772 for (i = 0; i < cfg->num_inputs; i++) { 3773 hda_nid_t nid = cfg->inputs[i].pin; 3774 int index, err, type_idx; 3775 3776 index = -1; 3777 for (j = 0; j < spec->num_muxes; j++) { 3778 index = get_connection_index(codec, spec->mux_nids[j], 3779 nid); 3780 if (index >= 0) 3781 break; 3782 } 3783 if (index < 0) 3784 continue; 3785 3786 label = hda_get_autocfg_input_label(codec, cfg, i); 3787 snd_hda_add_imux_item(imux, label, index, &type_idx); 3788 3789 err = create_elem_capture_vol(codec, nid, 3790 label, type_idx, 3791 HDA_INPUT); 3792 if (err < 0) 3793 return err; 3794 } 3795 spec->num_analog_muxes = imux->num_items; 3796 3797 if (imux->num_items) { 3798 /* 3799 * Set the current input for the muxes. 3800 * The STAC9221 has two input muxes with identical source 3801 * NID lists. Hopefully this won't get confused. 3802 */ 3803 for (i = 0; i < spec->num_muxes; i++) { 3804 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0, 3805 AC_VERB_SET_CONNECT_SEL, 3806 imux->items[0].index); 3807 } 3808 } 3809 3810 return 0; 3811 } 3812 3813 static void stac92xx_auto_init_multi_out(struct hda_codec *codec) 3814 { 3815 struct sigmatel_spec *spec = codec->spec; 3816 int i; 3817 3818 for (i = 0; i < spec->autocfg.line_outs; i++) { 3819 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 3820 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 3821 } 3822 } 3823 3824 static void stac92xx_auto_init_hp_out(struct hda_codec *codec) 3825 { 3826 struct sigmatel_spec *spec = codec->spec; 3827 int i; 3828 3829 for (i = 0; i < spec->autocfg.hp_outs; i++) { 3830 hda_nid_t pin; 3831 pin = spec->autocfg.hp_pins[i]; 3832 if (pin) /* connect to front */ 3833 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 3834 } 3835 for (i = 0; i < spec->autocfg.speaker_outs; i++) { 3836 hda_nid_t pin; 3837 pin = spec->autocfg.speaker_pins[i]; 3838 if (pin) /* connect to front */ 3839 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN); 3840 } 3841 } 3842 3843 static int is_dual_headphones(struct hda_codec *codec) 3844 { 3845 struct sigmatel_spec *spec = codec->spec; 3846 int i, valid_hps; 3847 3848 if (spec->autocfg.line_out_type != AUTO_PIN_SPEAKER_OUT || 3849 spec->autocfg.hp_outs <= 1) 3850 return 0; 3851 valid_hps = 0; 3852 for (i = 0; i < spec->autocfg.hp_outs; i++) { 3853 hda_nid_t nid = spec->autocfg.hp_pins[i]; 3854 unsigned int cfg = snd_hda_codec_get_pincfg(codec, nid); 3855 if (get_defcfg_location(cfg) & AC_JACK_LOC_SEPARATE) 3856 continue; 3857 valid_hps++; 3858 } 3859 return (valid_hps > 1); 3860 } 3861 3862 3863 static int stac92xx_parse_auto_config(struct hda_codec *codec) 3864 { 3865 struct sigmatel_spec *spec = codec->spec; 3866 hda_nid_t dig_out = 0, dig_in = 0; 3867 int hp_swap = 0; 3868 int i, err; 3869 3870 if ((err = snd_hda_parse_pin_def_config(codec, 3871 &spec->autocfg, 3872 spec->dmic_nids)) < 0) 3873 return err; 3874 if (! spec->autocfg.line_outs) 3875 return 0; /* can't find valid pin config */ 3876 3877 /* If we have no real line-out pin and multiple hp-outs, HPs should 3878 * be set up as multi-channel outputs. 3879 */ 3880 if (is_dual_headphones(codec)) { 3881 /* Copy hp_outs to line_outs, backup line_outs in 3882 * speaker_outs so that the following routines can handle 3883 * HP pins as primary outputs. 3884 */ 3885 snd_printdd("stac92xx: Enabling multi-HPs workaround\n"); 3886 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins, 3887 sizeof(spec->autocfg.line_out_pins)); 3888 spec->autocfg.speaker_outs = spec->autocfg.line_outs; 3889 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins, 3890 sizeof(spec->autocfg.hp_pins)); 3891 spec->autocfg.line_outs = spec->autocfg.hp_outs; 3892 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT; 3893 spec->autocfg.hp_outs = 0; 3894 hp_swap = 1; 3895 } 3896 if (spec->autocfg.mono_out_pin) { 3897 int dir = get_wcaps(codec, spec->autocfg.mono_out_pin) & 3898 (AC_WCAP_OUT_AMP | AC_WCAP_IN_AMP); 3899 u32 caps = query_amp_caps(codec, 3900 spec->autocfg.mono_out_pin, dir); 3901 hda_nid_t conn_list[1]; 3902 3903 /* get the mixer node and then the mono mux if it exists */ 3904 if (snd_hda_get_connections(codec, 3905 spec->autocfg.mono_out_pin, conn_list, 1) && 3906 snd_hda_get_connections(codec, conn_list[0], 3907 conn_list, 1) > 0) { 3908 3909 int wcaps = get_wcaps(codec, conn_list[0]); 3910 int wid_type = get_wcaps_type(wcaps); 3911 /* LR swap check, some stac925x have a mux that 3912 * changes the DACs output path instead of the 3913 * mono-mux path. 3914 */ 3915 if (wid_type == AC_WID_AUD_SEL && 3916 !(wcaps & AC_WCAP_LR_SWAP)) 3917 spec->mono_nid = conn_list[0]; 3918 } 3919 if (dir) { 3920 hda_nid_t nid = spec->autocfg.mono_out_pin; 3921 3922 /* most mono outs have a least a mute/unmute switch */ 3923 dir = (dir & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT; 3924 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, 3925 "Mono Playback Switch", 3926 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir)); 3927 if (err < 0) 3928 return err; 3929 /* check for volume support for the amp */ 3930 if ((caps & AC_AMPCAP_NUM_STEPS) 3931 >> AC_AMPCAP_NUM_STEPS_SHIFT) { 3932 err = stac92xx_add_control(spec, 3933 STAC_CTL_WIDGET_VOL, 3934 "Mono Playback Volume", 3935 HDA_COMPOSE_AMP_VAL(nid, 1, 0, dir)); 3936 if (err < 0) 3937 return err; 3938 } 3939 } 3940 3941 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin, 3942 AC_PINCTL_OUT_EN); 3943 } 3944 3945 if (!spec->multiout.num_dacs) { 3946 err = stac92xx_auto_fill_dac_nids(codec); 3947 if (err < 0) 3948 return err; 3949 err = stac92xx_auto_create_multi_out_ctls(codec, 3950 &spec->autocfg); 3951 if (err < 0) 3952 return err; 3953 } 3954 3955 /* setup analog beep controls */ 3956 if (spec->anabeep_nid > 0) { 3957 err = stac92xx_auto_create_beep_ctls(codec, 3958 spec->anabeep_nid); 3959 if (err < 0) 3960 return err; 3961 } 3962 3963 /* setup digital beep controls and input device */ 3964 #ifdef CONFIG_SND_HDA_INPUT_BEEP 3965 if (spec->digbeep_nid > 0) { 3966 hda_nid_t nid = spec->digbeep_nid; 3967 unsigned int caps; 3968 3969 err = stac92xx_auto_create_beep_ctls(codec, nid); 3970 if (err < 0) 3971 return err; 3972 err = snd_hda_attach_beep_device(codec, nid); 3973 if (err < 0) 3974 return err; 3975 if (codec->beep) { 3976 /* IDT/STAC codecs have linear beep tone parameter */ 3977 codec->beep->linear_tone = spec->linear_tone_beep; 3978 /* if no beep switch is available, make its own one */ 3979 caps = query_amp_caps(codec, nid, HDA_OUTPUT); 3980 if (!(caps & AC_AMPCAP_MUTE)) { 3981 err = stac92xx_beep_switch_ctl(codec); 3982 if (err < 0) 3983 return err; 3984 } 3985 } 3986 } 3987 #endif 3988 3989 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg); 3990 if (err < 0) 3991 return err; 3992 3993 /* All output parsing done, now restore the swapped hp pins */ 3994 if (hp_swap) { 3995 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins, 3996 sizeof(spec->autocfg.hp_pins)); 3997 spec->autocfg.hp_outs = spec->autocfg.line_outs; 3998 spec->autocfg.line_out_type = AUTO_PIN_HP_OUT; 3999 spec->autocfg.line_outs = 0; 4000 } 4001 4002 if (stac_check_auto_mic(codec)) { 4003 spec->auto_mic = 1; 4004 /* only one capture for auto-mic */ 4005 spec->num_adcs = 1; 4006 spec->num_caps = 1; 4007 spec->num_muxes = 1; 4008 } 4009 4010 for (i = 0; i < spec->num_caps; i++) { 4011 err = stac92xx_add_capvol_ctls(codec, spec->capvols[i], 4012 spec->capsws[i], i); 4013 if (err < 0) 4014 return err; 4015 } 4016 4017 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg); 4018 if (err < 0) 4019 return err; 4020 4021 if (spec->mono_nid > 0) { 4022 err = stac92xx_auto_create_mono_output_ctls(codec); 4023 if (err < 0) 4024 return err; 4025 } 4026 if (spec->num_dmics > 0 && !spec->dinput_mux) 4027 if ((err = stac92xx_auto_create_dmic_input_ctls(codec, 4028 &spec->autocfg)) < 0) 4029 return err; 4030 if (spec->num_muxes > 0) { 4031 err = stac92xx_auto_create_mux_input_ctls(codec); 4032 if (err < 0) 4033 return err; 4034 } 4035 if (spec->num_smuxes > 0) { 4036 err = stac92xx_auto_create_spdif_mux_ctls(codec); 4037 if (err < 0) 4038 return err; 4039 } 4040 4041 err = stac92xx_add_input_source(spec); 4042 if (err < 0) 4043 return err; 4044 4045 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 4046 if (spec->multiout.max_channels > 2) 4047 spec->surr_switch = 1; 4048 4049 /* find digital out and in converters */ 4050 for (i = codec->start_nid; i < codec->start_nid + codec->num_nodes; i++) { 4051 unsigned int wid_caps = get_wcaps(codec, i); 4052 if (wid_caps & AC_WCAP_DIGITAL) { 4053 switch (get_wcaps_type(wid_caps)) { 4054 case AC_WID_AUD_OUT: 4055 if (!dig_out) 4056 dig_out = i; 4057 break; 4058 case AC_WID_AUD_IN: 4059 if (!dig_in) 4060 dig_in = i; 4061 break; 4062 } 4063 } 4064 } 4065 if (spec->autocfg.dig_outs) 4066 spec->multiout.dig_out_nid = dig_out; 4067 if (dig_in && spec->autocfg.dig_in_pin) 4068 spec->dig_in_nid = dig_in; 4069 4070 if (spec->kctls.list) 4071 spec->mixers[spec->num_mixers++] = spec->kctls.list; 4072 4073 spec->input_mux = &spec->private_imux; 4074 if (!spec->dinput_mux) 4075 spec->dinput_mux = &spec->private_dimux; 4076 spec->sinput_mux = &spec->private_smux; 4077 spec->mono_mux = &spec->private_mono_mux; 4078 return 1; 4079 } 4080 4081 /* add playback controls for HP output */ 4082 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec, 4083 struct auto_pin_cfg *cfg) 4084 { 4085 struct sigmatel_spec *spec = codec->spec; 4086 hda_nid_t pin = cfg->hp_pins[0]; 4087 4088 if (! pin) 4089 return 0; 4090 4091 if (is_jack_detectable(codec, pin)) 4092 spec->hp_detect = 1; 4093 4094 return 0; 4095 } 4096 4097 /* add playback controls for LFE output */ 4098 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec, 4099 struct auto_pin_cfg *cfg) 4100 { 4101 struct sigmatel_spec *spec = codec->spec; 4102 int err; 4103 hda_nid_t lfe_pin = 0x0; 4104 int i; 4105 4106 /* 4107 * search speaker outs and line outs for a mono speaker pin 4108 * with an amp. If one is found, add LFE controls 4109 * for it. 4110 */ 4111 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) { 4112 hda_nid_t pin = spec->autocfg.speaker_pins[i]; 4113 unsigned int wcaps = get_wcaps(codec, pin); 4114 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 4115 if (wcaps == AC_WCAP_OUT_AMP) 4116 /* found a mono speaker with an amp, must be lfe */ 4117 lfe_pin = pin; 4118 } 4119 4120 /* if speaker_outs is 0, then speakers may be in line_outs */ 4121 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) { 4122 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) { 4123 hda_nid_t pin = spec->autocfg.line_out_pins[i]; 4124 unsigned int defcfg; 4125 defcfg = snd_hda_codec_get_pincfg(codec, pin); 4126 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) { 4127 unsigned int wcaps = get_wcaps(codec, pin); 4128 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 4129 if (wcaps == AC_WCAP_OUT_AMP) 4130 /* found a mono speaker with an amp, 4131 must be lfe */ 4132 lfe_pin = pin; 4133 } 4134 } 4135 } 4136 4137 if (lfe_pin) { 4138 err = create_controls(codec, "LFE", lfe_pin, 1); 4139 if (err < 0) 4140 return err; 4141 } 4142 4143 return 0; 4144 } 4145 4146 static int stac9200_parse_auto_config(struct hda_codec *codec) 4147 { 4148 struct sigmatel_spec *spec = codec->spec; 4149 int err; 4150 4151 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) 4152 return err; 4153 4154 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) 4155 return err; 4156 4157 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0) 4158 return err; 4159 4160 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0) 4161 return err; 4162 4163 if (spec->num_muxes > 0) { 4164 err = stac92xx_auto_create_mux_input_ctls(codec); 4165 if (err < 0) 4166 return err; 4167 } 4168 4169 err = stac92xx_add_input_source(spec); 4170 if (err < 0) 4171 return err; 4172 4173 if (spec->autocfg.dig_outs) 4174 spec->multiout.dig_out_nid = 0x05; 4175 if (spec->autocfg.dig_in_pin) 4176 spec->dig_in_nid = 0x04; 4177 4178 if (spec->kctls.list) 4179 spec->mixers[spec->num_mixers++] = spec->kctls.list; 4180 4181 spec->input_mux = &spec->private_imux; 4182 spec->dinput_mux = &spec->private_dimux; 4183 4184 return 1; 4185 } 4186 4187 /* 4188 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a 4189 * funky external mute control using GPIO pins. 4190 */ 4191 4192 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask, 4193 unsigned int dir_mask, unsigned int data) 4194 { 4195 unsigned int gpiostate, gpiomask, gpiodir; 4196 4197 snd_printdd("%s msk %x dir %x gpio %x\n", __func__, mask, dir_mask, data); 4198 4199 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 4200 AC_VERB_GET_GPIO_DATA, 0); 4201 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask); 4202 4203 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 4204 AC_VERB_GET_GPIO_MASK, 0); 4205 gpiomask |= mask; 4206 4207 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 4208 AC_VERB_GET_GPIO_DIRECTION, 0); 4209 gpiodir |= dir_mask; 4210 4211 /* Configure GPIOx as CMOS */ 4212 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0); 4213 4214 snd_hda_codec_write(codec, codec->afg, 0, 4215 AC_VERB_SET_GPIO_MASK, gpiomask); 4216 snd_hda_codec_read(codec, codec->afg, 0, 4217 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */ 4218 4219 msleep(1); 4220 4221 snd_hda_codec_read(codec, codec->afg, 0, 4222 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */ 4223 } 4224 4225 static int stac_add_event(struct hda_codec *codec, hda_nid_t nid, 4226 unsigned char type, int data) 4227 { 4228 struct hda_jack_tbl *event; 4229 4230 event = snd_hda_jack_tbl_new(codec, nid); 4231 if (!event) 4232 return -ENOMEM; 4233 event->action = type; 4234 event->private_data = data; 4235 4236 return 0; 4237 } 4238 4239 static void handle_unsol_event(struct hda_codec *codec, 4240 struct hda_jack_tbl *event); 4241 4242 /* check if given nid is a valid pin and no other events are assigned 4243 * to it. If OK, assign the event, set the unsol flag, and returns 1. 4244 * Otherwise, returns zero. 4245 */ 4246 static int enable_pin_detect(struct hda_codec *codec, hda_nid_t nid, 4247 unsigned int type) 4248 { 4249 struct hda_jack_tbl *event; 4250 4251 if (!is_jack_detectable(codec, nid)) 4252 return 0; 4253 event = snd_hda_jack_tbl_new(codec, nid); 4254 if (!event) 4255 return -ENOMEM; 4256 if (event->action && event->action != type) 4257 return 0; 4258 event->action = type; 4259 event->callback = handle_unsol_event; 4260 snd_hda_jack_detect_enable(codec, nid, 0); 4261 return 1; 4262 } 4263 4264 static int is_nid_out_jack_pin(struct auto_pin_cfg *cfg, hda_nid_t nid) 4265 { 4266 int i; 4267 for (i = 0; i < cfg->hp_outs; i++) 4268 if (cfg->hp_pins[i] == nid) 4269 return 1; /* nid is a HP-Out */ 4270 for (i = 0; i < cfg->line_outs; i++) 4271 if (cfg->line_out_pins[i] == nid) 4272 return 1; /* nid is a line-Out */ 4273 return 0; /* nid is not a HP-Out */ 4274 }; 4275 4276 static void stac92xx_power_down(struct hda_codec *codec) 4277 { 4278 struct sigmatel_spec *spec = codec->spec; 4279 4280 /* power down inactive DACs */ 4281 const hda_nid_t *dac; 4282 for (dac = spec->dac_list; *dac; dac++) 4283 if (!check_all_dac_nids(spec, *dac)) 4284 snd_hda_codec_write(codec, *dac, 0, 4285 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 4286 } 4287 4288 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid, 4289 int enable); 4290 4291 static inline int get_int_hint(struct hda_codec *codec, const char *key, 4292 int *valp) 4293 { 4294 const char *p; 4295 p = snd_hda_get_hint(codec, key); 4296 if (p) { 4297 unsigned long val; 4298 if (!strict_strtoul(p, 0, &val)) { 4299 *valp = val; 4300 return 1; 4301 } 4302 } 4303 return 0; 4304 } 4305 4306 /* override some hints from the hwdep entry */ 4307 static void stac_store_hints(struct hda_codec *codec) 4308 { 4309 struct sigmatel_spec *spec = codec->spec; 4310 int val; 4311 4312 val = snd_hda_get_bool_hint(codec, "hp_detect"); 4313 if (val >= 0) 4314 spec->hp_detect = val; 4315 if (get_int_hint(codec, "gpio_mask", &spec->gpio_mask)) { 4316 spec->eapd_mask = spec->gpio_dir = spec->gpio_data = 4317 spec->gpio_mask; 4318 } 4319 if (get_int_hint(codec, "gpio_dir", &spec->gpio_dir)) 4320 spec->gpio_mask &= spec->gpio_mask; 4321 if (get_int_hint(codec, "gpio_data", &spec->gpio_data)) 4322 spec->gpio_dir &= spec->gpio_mask; 4323 if (get_int_hint(codec, "eapd_mask", &spec->eapd_mask)) 4324 spec->eapd_mask &= spec->gpio_mask; 4325 if (get_int_hint(codec, "gpio_mute", &spec->gpio_mute)) 4326 spec->gpio_mute &= spec->gpio_mask; 4327 val = snd_hda_get_bool_hint(codec, "eapd_switch"); 4328 if (val >= 0) 4329 spec->eapd_switch = val; 4330 } 4331 4332 static void stac_issue_unsol_events(struct hda_codec *codec, int num_pins, 4333 const hda_nid_t *pins) 4334 { 4335 while (num_pins--) 4336 stac_issue_unsol_event(codec, *pins++); 4337 } 4338 4339 /* fake event to set up pins */ 4340 static void stac_fake_hp_events(struct hda_codec *codec) 4341 { 4342 struct sigmatel_spec *spec = codec->spec; 4343 4344 if (spec->autocfg.hp_outs) 4345 stac_issue_unsol_events(codec, spec->autocfg.hp_outs, 4346 spec->autocfg.hp_pins); 4347 if (spec->autocfg.line_outs && 4348 spec->autocfg.line_out_pins[0] != spec->autocfg.hp_pins[0]) 4349 stac_issue_unsol_events(codec, spec->autocfg.line_outs, 4350 spec->autocfg.line_out_pins); 4351 } 4352 4353 static int stac92xx_init(struct hda_codec *codec) 4354 { 4355 struct sigmatel_spec *spec = codec->spec; 4356 struct auto_pin_cfg *cfg = &spec->autocfg; 4357 unsigned int gpio; 4358 int i; 4359 4360 if (spec->init) 4361 snd_hda_sequence_write(codec, spec->init); 4362 4363 /* power down adcs initially */ 4364 if (spec->powerdown_adcs) 4365 for (i = 0; i < spec->num_adcs; i++) 4366 snd_hda_codec_write(codec, 4367 spec->adc_nids[i], 0, 4368 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 4369 4370 /* override some hints */ 4371 stac_store_hints(codec); 4372 4373 /* set up GPIO */ 4374 gpio = spec->gpio_data; 4375 /* turn on EAPD statically when spec->eapd_switch isn't set. 4376 * otherwise, unsol event will turn it on/off dynamically 4377 */ 4378 if (!spec->eapd_switch) 4379 gpio |= spec->eapd_mask; 4380 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, gpio); 4381 4382 /* set up pins */ 4383 if (spec->hp_detect) { 4384 /* Enable unsolicited responses on the HP widget */ 4385 for (i = 0; i < cfg->hp_outs; i++) { 4386 hda_nid_t nid = cfg->hp_pins[i]; 4387 enable_pin_detect(codec, nid, STAC_HP_EVENT); 4388 } 4389 if (cfg->line_out_type == AUTO_PIN_LINE_OUT && 4390 cfg->speaker_outs > 0) { 4391 /* enable pin-detect for line-outs as well */ 4392 for (i = 0; i < cfg->line_outs; i++) { 4393 hda_nid_t nid = cfg->line_out_pins[i]; 4394 enable_pin_detect(codec, nid, STAC_LO_EVENT); 4395 } 4396 } 4397 4398 /* force to enable the first line-out; the others are set up 4399 * in unsol_event 4400 */ 4401 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0], 4402 AC_PINCTL_OUT_EN); 4403 /* fake event to set up pins */ 4404 stac_fake_hp_events(codec); 4405 } else { 4406 stac92xx_auto_init_multi_out(codec); 4407 stac92xx_auto_init_hp_out(codec); 4408 for (i = 0; i < cfg->hp_outs; i++) 4409 stac_toggle_power_map(codec, cfg->hp_pins[i], 1); 4410 } 4411 if (spec->auto_mic) { 4412 /* initialize connection to analog input */ 4413 if (spec->dmux_nids) 4414 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0, 4415 AC_VERB_SET_CONNECT_SEL, 0); 4416 if (enable_pin_detect(codec, spec->ext_mic.pin, STAC_MIC_EVENT)) 4417 stac_issue_unsol_event(codec, spec->ext_mic.pin); 4418 if (enable_pin_detect(codec, spec->dock_mic.pin, 4419 STAC_MIC_EVENT)) 4420 stac_issue_unsol_event(codec, spec->dock_mic.pin); 4421 } 4422 for (i = 0; i < cfg->num_inputs; i++) { 4423 hda_nid_t nid = cfg->inputs[i].pin; 4424 int type = cfg->inputs[i].type; 4425 unsigned int pinctl, conf; 4426 if (type == AUTO_PIN_MIC) { 4427 /* for mic pins, force to initialize */ 4428 pinctl = snd_hda_get_default_vref(codec, nid); 4429 pinctl |= AC_PINCTL_IN_EN; 4430 stac92xx_auto_set_pinctl(codec, nid, pinctl); 4431 } else { 4432 pinctl = snd_hda_codec_read(codec, nid, 0, 4433 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4434 /* if PINCTL already set then skip */ 4435 /* Also, if both INPUT and OUTPUT are set, 4436 * it must be a BIOS bug; need to override, too 4437 */ 4438 if (!(pinctl & AC_PINCTL_IN_EN) || 4439 (pinctl & AC_PINCTL_OUT_EN)) { 4440 pinctl &= ~AC_PINCTL_OUT_EN; 4441 pinctl |= AC_PINCTL_IN_EN; 4442 stac92xx_auto_set_pinctl(codec, nid, pinctl); 4443 } 4444 } 4445 conf = snd_hda_codec_get_pincfg(codec, nid); 4446 if (get_defcfg_connect(conf) != AC_JACK_PORT_FIXED) { 4447 if (enable_pin_detect(codec, nid, STAC_INSERT_EVENT)) 4448 stac_issue_unsol_event(codec, nid); 4449 } 4450 } 4451 for (i = 0; i < spec->num_dmics; i++) 4452 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i], 4453 AC_PINCTL_IN_EN); 4454 if (cfg->dig_out_pins[0]) 4455 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pins[0], 4456 AC_PINCTL_OUT_EN); 4457 if (cfg->dig_in_pin) 4458 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin, 4459 AC_PINCTL_IN_EN); 4460 for (i = 0; i < spec->num_pwrs; i++) { 4461 hda_nid_t nid = spec->pwr_nids[i]; 4462 unsigned int pinctl, def_conf; 4463 4464 def_conf = snd_hda_codec_get_pincfg(codec, nid); 4465 def_conf = get_defcfg_connect(def_conf); 4466 if (def_conf == AC_JACK_PORT_NONE) { 4467 /* power off unused ports */ 4468 stac_toggle_power_map(codec, nid, 0); 4469 continue; 4470 } 4471 if (def_conf == AC_JACK_PORT_FIXED) { 4472 /* no need for jack detection for fixed pins */ 4473 stac_toggle_power_map(codec, nid, 1); 4474 continue; 4475 } 4476 /* power on when no jack detection is available */ 4477 /* or when the VREF is used for controlling LED */ 4478 if (!spec->hp_detect || 4479 spec->vref_mute_led_nid == nid || 4480 !is_jack_detectable(codec, nid)) { 4481 stac_toggle_power_map(codec, nid, 1); 4482 continue; 4483 } 4484 4485 if (is_nid_out_jack_pin(cfg, nid)) 4486 continue; /* already has an unsol event */ 4487 4488 pinctl = snd_hda_codec_read(codec, nid, 0, 4489 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4490 /* outputs are only ports capable of power management 4491 * any attempts on powering down a input port cause the 4492 * referenced VREF to act quirky. 4493 */ 4494 if (pinctl & AC_PINCTL_IN_EN) { 4495 stac_toggle_power_map(codec, nid, 1); 4496 continue; 4497 } 4498 if (enable_pin_detect(codec, nid, STAC_PWR_EVENT)) { 4499 stac_issue_unsol_event(codec, nid); 4500 continue; 4501 } 4502 /* none of the above, turn the port OFF */ 4503 stac_toggle_power_map(codec, nid, 0); 4504 } 4505 4506 /* sync mute LED */ 4507 if (spec->gpio_led) { 4508 if (spec->vmaster_mute.hook) 4509 snd_hda_sync_vmaster_hook(&spec->vmaster_mute); 4510 else /* the very first init call doesn't have vmaster yet */ 4511 stac92xx_update_led_status(codec, false); 4512 } 4513 4514 /* sync the power-map */ 4515 if (spec->num_pwrs) 4516 snd_hda_codec_write(codec, codec->afg, 0, 4517 AC_VERB_IDT_SET_POWER_MAP, 4518 spec->power_map_bits); 4519 if (spec->dac_list) 4520 stac92xx_power_down(codec); 4521 return 0; 4522 } 4523 4524 static void stac92xx_free_kctls(struct hda_codec *codec) 4525 { 4526 struct sigmatel_spec *spec = codec->spec; 4527 4528 if (spec->kctls.list) { 4529 struct snd_kcontrol_new *kctl = spec->kctls.list; 4530 int i; 4531 for (i = 0; i < spec->kctls.used; i++) 4532 kfree(kctl[i].name); 4533 } 4534 snd_array_free(&spec->kctls); 4535 } 4536 4537 static void stac92xx_shutup_pins(struct hda_codec *codec) 4538 { 4539 unsigned int i, def_conf; 4540 4541 if (codec->bus->shutdown) 4542 return; 4543 for (i = 0; i < codec->init_pins.used; i++) { 4544 struct hda_pincfg *pin = snd_array_elem(&codec->init_pins, i); 4545 def_conf = snd_hda_codec_get_pincfg(codec, pin->nid); 4546 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) 4547 snd_hda_set_pin_ctl(codec, pin->nid, 0); 4548 } 4549 } 4550 4551 static void stac92xx_shutup(struct hda_codec *codec) 4552 { 4553 struct sigmatel_spec *spec = codec->spec; 4554 4555 stac92xx_shutup_pins(codec); 4556 4557 if (spec->eapd_mask) 4558 stac_gpio_set(codec, spec->gpio_mask, 4559 spec->gpio_dir, spec->gpio_data & 4560 ~spec->eapd_mask); 4561 } 4562 4563 static void stac92xx_free(struct hda_codec *codec) 4564 { 4565 struct sigmatel_spec *spec = codec->spec; 4566 4567 if (! spec) 4568 return; 4569 4570 stac92xx_shutup(codec); 4571 4572 kfree(spec); 4573 snd_hda_detach_beep_device(codec); 4574 } 4575 4576 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid, 4577 unsigned int flag) 4578 { 4579 unsigned int old_ctl, pin_ctl; 4580 4581 pin_ctl = snd_hda_codec_read(codec, nid, 4582 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 4583 4584 if (pin_ctl & AC_PINCTL_IN_EN) { 4585 /* 4586 * we need to check the current set-up direction of 4587 * shared input pins since they can be switched via 4588 * "xxx as Output" mixer switch 4589 */ 4590 struct sigmatel_spec *spec = codec->spec; 4591 if (nid == spec->line_switch || nid == spec->mic_switch) 4592 return; 4593 } 4594 4595 old_ctl = pin_ctl; 4596 /* if setting pin direction bits, clear the current 4597 direction bits first */ 4598 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)) 4599 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 4600 4601 pin_ctl |= flag; 4602 if (old_ctl != pin_ctl) 4603 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl); 4604 } 4605 4606 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid, 4607 unsigned int flag) 4608 { 4609 unsigned int pin_ctl = snd_hda_codec_read(codec, nid, 4610 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 4611 if (pin_ctl & flag) 4612 snd_hda_set_pin_ctl_cache(codec, nid, pin_ctl & ~flag); 4613 } 4614 4615 static inline int get_pin_presence(struct hda_codec *codec, hda_nid_t nid) 4616 { 4617 if (!nid) 4618 return 0; 4619 return snd_hda_jack_detect(codec, nid); 4620 } 4621 4622 static void stac92xx_line_out_detect(struct hda_codec *codec, 4623 int presence) 4624 { 4625 struct sigmatel_spec *spec = codec->spec; 4626 struct auto_pin_cfg *cfg = &spec->autocfg; 4627 int i; 4628 4629 if (cfg->speaker_outs == 0) 4630 return; 4631 4632 for (i = 0; i < cfg->line_outs; i++) { 4633 if (presence) 4634 break; 4635 presence = get_pin_presence(codec, cfg->line_out_pins[i]); 4636 if (presence) { 4637 unsigned int pinctl; 4638 pinctl = snd_hda_codec_read(codec, 4639 cfg->line_out_pins[i], 0, 4640 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4641 if (pinctl & AC_PINCTL_IN_EN) 4642 presence = 0; /* mic- or line-input */ 4643 } 4644 } 4645 4646 if (presence) { 4647 /* disable speakers */ 4648 for (i = 0; i < cfg->speaker_outs; i++) 4649 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i], 4650 AC_PINCTL_OUT_EN); 4651 if (spec->eapd_mask && spec->eapd_switch) 4652 stac_gpio_set(codec, spec->gpio_mask, 4653 spec->gpio_dir, spec->gpio_data & 4654 ~spec->eapd_mask); 4655 } else { 4656 /* enable speakers */ 4657 for (i = 0; i < cfg->speaker_outs; i++) 4658 stac92xx_set_pinctl(codec, cfg->speaker_pins[i], 4659 AC_PINCTL_OUT_EN); 4660 if (spec->eapd_mask && spec->eapd_switch) 4661 stac_gpio_set(codec, spec->gpio_mask, 4662 spec->gpio_dir, spec->gpio_data | 4663 spec->eapd_mask); 4664 } 4665 } 4666 4667 /* return non-zero if the hp-pin of the given array index isn't 4668 * a jack-detection target 4669 */ 4670 static int no_hp_sensing(struct sigmatel_spec *spec, int i) 4671 { 4672 struct auto_pin_cfg *cfg = &spec->autocfg; 4673 4674 /* ignore sensing of shared line and mic jacks */ 4675 if (cfg->hp_pins[i] == spec->line_switch) 4676 return 1; 4677 if (cfg->hp_pins[i] == spec->mic_switch) 4678 return 1; 4679 /* ignore if the pin is set as line-out */ 4680 if (cfg->hp_pins[i] == spec->hp_switch) 4681 return 1; 4682 return 0; 4683 } 4684 4685 static void stac92xx_hp_detect(struct hda_codec *codec) 4686 { 4687 struct sigmatel_spec *spec = codec->spec; 4688 struct auto_pin_cfg *cfg = &spec->autocfg; 4689 int i, presence; 4690 4691 presence = 0; 4692 if (spec->gpio_mute) 4693 presence = !(snd_hda_codec_read(codec, codec->afg, 0, 4694 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute); 4695 4696 for (i = 0; i < cfg->hp_outs; i++) { 4697 if (presence) 4698 break; 4699 if (no_hp_sensing(spec, i)) 4700 continue; 4701 presence = get_pin_presence(codec, cfg->hp_pins[i]); 4702 if (presence) { 4703 unsigned int pinctl; 4704 pinctl = snd_hda_codec_read(codec, cfg->hp_pins[i], 0, 4705 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 4706 if (pinctl & AC_PINCTL_IN_EN) 4707 presence = 0; /* mic- or line-input */ 4708 } 4709 } 4710 4711 if (presence) { 4712 /* disable lineouts */ 4713 if (spec->hp_switch) 4714 stac92xx_reset_pinctl(codec, spec->hp_switch, 4715 AC_PINCTL_OUT_EN); 4716 for (i = 0; i < cfg->line_outs; i++) 4717 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i], 4718 AC_PINCTL_OUT_EN); 4719 } else { 4720 /* enable lineouts */ 4721 if (spec->hp_switch) 4722 stac92xx_set_pinctl(codec, spec->hp_switch, 4723 AC_PINCTL_OUT_EN); 4724 for (i = 0; i < cfg->line_outs; i++) 4725 stac92xx_set_pinctl(codec, cfg->line_out_pins[i], 4726 AC_PINCTL_OUT_EN); 4727 } 4728 stac92xx_line_out_detect(codec, presence); 4729 /* toggle hp outs */ 4730 for (i = 0; i < cfg->hp_outs; i++) { 4731 unsigned int val = AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN; 4732 if (no_hp_sensing(spec, i)) 4733 continue; 4734 if (1 /*presence*/) 4735 stac92xx_set_pinctl(codec, cfg->hp_pins[i], val); 4736 #if 0 /* FIXME */ 4737 /* Resetting the pinctl like below may lead to (a sort of) regressions 4738 * on some devices since they use the HP pin actually for line/speaker 4739 * outs although the default pin config shows a different pin (that is 4740 * wrong and useless). 4741 * 4742 * So, it's basically a problem of default pin configs, likely a BIOS issue. 4743 * But, disabling the code below just works around it, and I'm too tired of 4744 * bug reports with such devices... 4745 */ 4746 else 4747 stac92xx_reset_pinctl(codec, cfg->hp_pins[i], val); 4748 #endif /* FIXME */ 4749 } 4750 } 4751 4752 static void stac_toggle_power_map(struct hda_codec *codec, hda_nid_t nid, 4753 int enable) 4754 { 4755 struct sigmatel_spec *spec = codec->spec; 4756 unsigned int idx, val; 4757 4758 for (idx = 0; idx < spec->num_pwrs; idx++) { 4759 if (spec->pwr_nids[idx] == nid) 4760 break; 4761 } 4762 if (idx >= spec->num_pwrs) 4763 return; 4764 4765 idx = 1 << idx; 4766 4767 val = spec->power_map_bits; 4768 if (enable) 4769 val &= ~idx; 4770 else 4771 val |= idx; 4772 4773 /* power down unused output ports */ 4774 if (val != spec->power_map_bits) { 4775 spec->power_map_bits = val; 4776 snd_hda_codec_write(codec, codec->afg, 0, 4777 AC_VERB_IDT_SET_POWER_MAP, val); 4778 } 4779 } 4780 4781 static void stac92xx_pin_sense(struct hda_codec *codec, hda_nid_t nid) 4782 { 4783 stac_toggle_power_map(codec, nid, get_pin_presence(codec, nid)); 4784 } 4785 4786 /* get the pin connection (fixed, none, etc) */ 4787 static unsigned int stac_get_defcfg_connect(struct hda_codec *codec, int idx) 4788 { 4789 struct sigmatel_spec *spec = codec->spec; 4790 unsigned int cfg; 4791 4792 cfg = snd_hda_codec_get_pincfg(codec, spec->pin_nids[idx]); 4793 return get_defcfg_connect(cfg); 4794 } 4795 4796 static int stac92xx_connected_ports(struct hda_codec *codec, 4797 const hda_nid_t *nids, int num_nids) 4798 { 4799 struct sigmatel_spec *spec = codec->spec; 4800 int idx, num; 4801 unsigned int def_conf; 4802 4803 for (num = 0; num < num_nids; num++) { 4804 for (idx = 0; idx < spec->num_pins; idx++) 4805 if (spec->pin_nids[idx] == nids[num]) 4806 break; 4807 if (idx >= spec->num_pins) 4808 break; 4809 def_conf = stac_get_defcfg_connect(codec, idx); 4810 if (def_conf == AC_JACK_PORT_NONE) 4811 break; 4812 } 4813 return num; 4814 } 4815 4816 static void stac92xx_mic_detect(struct hda_codec *codec) 4817 { 4818 struct sigmatel_spec *spec = codec->spec; 4819 struct sigmatel_mic_route *mic; 4820 4821 if (get_pin_presence(codec, spec->ext_mic.pin)) 4822 mic = &spec->ext_mic; 4823 else if (get_pin_presence(codec, spec->dock_mic.pin)) 4824 mic = &spec->dock_mic; 4825 else 4826 mic = &spec->int_mic; 4827 if (mic->dmux_idx >= 0) 4828 snd_hda_codec_write_cache(codec, spec->dmux_nids[0], 0, 4829 AC_VERB_SET_CONNECT_SEL, 4830 mic->dmux_idx); 4831 if (mic->mux_idx >= 0) 4832 snd_hda_codec_write_cache(codec, spec->mux_nids[0], 0, 4833 AC_VERB_SET_CONNECT_SEL, 4834 mic->mux_idx); 4835 } 4836 4837 static void handle_unsol_event(struct hda_codec *codec, 4838 struct hda_jack_tbl *event) 4839 { 4840 struct sigmatel_spec *spec = codec->spec; 4841 int data; 4842 4843 switch (event->action) { 4844 case STAC_HP_EVENT: 4845 case STAC_LO_EVENT: 4846 stac92xx_hp_detect(codec); 4847 break; 4848 case STAC_MIC_EVENT: 4849 stac92xx_mic_detect(codec); 4850 break; 4851 } 4852 4853 switch (event->action) { 4854 case STAC_HP_EVENT: 4855 case STAC_LO_EVENT: 4856 case STAC_MIC_EVENT: 4857 case STAC_INSERT_EVENT: 4858 case STAC_PWR_EVENT: 4859 if (spec->num_pwrs > 0) 4860 stac92xx_pin_sense(codec, event->nid); 4861 4862 switch (codec->subsystem_id) { 4863 case 0x103c308f: 4864 if (event->nid == 0xb) { 4865 int pin = AC_PINCTL_IN_EN; 4866 4867 if (get_pin_presence(codec, 0xa) 4868 && get_pin_presence(codec, 0xb)) 4869 pin |= AC_PINCTL_VREF_80; 4870 if (!get_pin_presence(codec, 0xb)) 4871 pin |= AC_PINCTL_VREF_80; 4872 4873 /* toggle VREF state based on mic + hp pin 4874 * status 4875 */ 4876 stac92xx_auto_set_pinctl(codec, 0x0a, pin); 4877 } 4878 } 4879 break; 4880 case STAC_VREF_EVENT: 4881 data = snd_hda_codec_read(codec, codec->afg, 0, 4882 AC_VERB_GET_GPIO_DATA, 0); 4883 /* toggle VREF state based on GPIOx status */ 4884 snd_hda_codec_write(codec, codec->afg, 0, 0x7e0, 4885 !!(data & (1 << event->private_data))); 4886 break; 4887 } 4888 } 4889 4890 static void stac_issue_unsol_event(struct hda_codec *codec, hda_nid_t nid) 4891 { 4892 struct hda_jack_tbl *event = snd_hda_jack_tbl_get(codec, nid); 4893 if (!event) 4894 return; 4895 handle_unsol_event(codec, event); 4896 } 4897 4898 static int hp_blike_system(u32 subsystem_id); 4899 4900 static void set_hp_led_gpio(struct hda_codec *codec) 4901 { 4902 struct sigmatel_spec *spec = codec->spec; 4903 unsigned int gpio; 4904 4905 if (spec->gpio_led) 4906 return; 4907 4908 gpio = snd_hda_param_read(codec, codec->afg, AC_PAR_GPIO_CAP); 4909 gpio &= AC_GPIO_IO_COUNT; 4910 if (gpio > 3) 4911 spec->gpio_led = 0x08; /* GPIO 3 */ 4912 else 4913 spec->gpio_led = 0x01; /* GPIO 0 */ 4914 } 4915 4916 /* 4917 * This method searches for the mute LED GPIO configuration 4918 * provided as OEM string in SMBIOS. The format of that string 4919 * is HP_Mute_LED_P_G or HP_Mute_LED_P 4920 * where P can be 0 or 1 and defines mute LED GPIO control state (low/high) 4921 * that corresponds to the NOT muted state of the master volume 4922 * and G is the index of the GPIO to use as the mute LED control (0..9) 4923 * If _G portion is missing it is assigned based on the codec ID 4924 * 4925 * So, HP B-series like systems may have HP_Mute_LED_0 (current models) 4926 * or HP_Mute_LED_0_3 (future models) OEM SMBIOS strings 4927 * 4928 * 4929 * The dv-series laptops don't seem to have the HP_Mute_LED* strings in 4930 * SMBIOS - at least the ones I have seen do not have them - which include 4931 * my own system (HP Pavilion dv6-1110ax) and my cousin's 4932 * HP Pavilion dv9500t CTO. 4933 * Need more information on whether it is true across the entire series. 4934 * -- kunal 4935 */ 4936 static int find_mute_led_cfg(struct hda_codec *codec, int default_polarity) 4937 { 4938 struct sigmatel_spec *spec = codec->spec; 4939 const struct dmi_device *dev = NULL; 4940 4941 if (get_int_hint(codec, "gpio_led", &spec->gpio_led)) { 4942 get_int_hint(codec, "gpio_led_polarity", 4943 &spec->gpio_led_polarity); 4944 return 1; 4945 } 4946 if ((codec->subsystem_id >> 16) == PCI_VENDOR_ID_HP) { 4947 while ((dev = dmi_find_device(DMI_DEV_TYPE_OEM_STRING, 4948 NULL, dev))) { 4949 if (sscanf(dev->name, "HP_Mute_LED_%d_%x", 4950 &spec->gpio_led_polarity, 4951 &spec->gpio_led) == 2) { 4952 unsigned int max_gpio; 4953 max_gpio = snd_hda_param_read(codec, codec->afg, 4954 AC_PAR_GPIO_CAP); 4955 max_gpio &= AC_GPIO_IO_COUNT; 4956 if (spec->gpio_led < max_gpio) 4957 spec->gpio_led = 1 << spec->gpio_led; 4958 else 4959 spec->vref_mute_led_nid = spec->gpio_led; 4960 return 1; 4961 } 4962 if (sscanf(dev->name, "HP_Mute_LED_%d", 4963 &spec->gpio_led_polarity) == 1) { 4964 set_hp_led_gpio(codec); 4965 return 1; 4966 } 4967 /* BIOS bug: unfilled OEM string */ 4968 if (strstr(dev->name, "HP_Mute_LED_P_G")) { 4969 set_hp_led_gpio(codec); 4970 switch (codec->subsystem_id) { 4971 case 0x103c148a: 4972 spec->gpio_led_polarity = 0; 4973 break; 4974 default: 4975 spec->gpio_led_polarity = 1; 4976 break; 4977 } 4978 return 1; 4979 } 4980 } 4981 4982 /* 4983 * Fallback case - if we don't find the DMI strings, 4984 * we statically set the GPIO - if not a B-series system 4985 * and default polarity is provided 4986 */ 4987 if (!hp_blike_system(codec->subsystem_id) && 4988 (default_polarity == 0 || default_polarity == 1)) { 4989 set_hp_led_gpio(codec); 4990 spec->gpio_led_polarity = default_polarity; 4991 return 1; 4992 } 4993 } 4994 return 0; 4995 } 4996 4997 static int hp_blike_system(u32 subsystem_id) 4998 { 4999 switch (subsystem_id) { 5000 case 0x103c1520: 5001 case 0x103c1521: 5002 case 0x103c1523: 5003 case 0x103c1524: 5004 case 0x103c1525: 5005 case 0x103c1722: 5006 case 0x103c1723: 5007 case 0x103c1724: 5008 case 0x103c1725: 5009 case 0x103c1726: 5010 case 0x103c1727: 5011 case 0x103c1728: 5012 case 0x103c1729: 5013 case 0x103c172a: 5014 case 0x103c172b: 5015 case 0x103c307e: 5016 case 0x103c307f: 5017 case 0x103c3080: 5018 case 0x103c3081: 5019 case 0x103c7007: 5020 case 0x103c7008: 5021 return 1; 5022 } 5023 return 0; 5024 } 5025 5026 #ifdef CONFIG_PROC_FS 5027 static void stac92hd_proc_hook(struct snd_info_buffer *buffer, 5028 struct hda_codec *codec, hda_nid_t nid) 5029 { 5030 if (nid == codec->afg) 5031 snd_iprintf(buffer, "Power-Map: 0x%02x\n", 5032 snd_hda_codec_read(codec, nid, 0, 5033 AC_VERB_IDT_GET_POWER_MAP, 0)); 5034 } 5035 5036 static void analog_loop_proc_hook(struct snd_info_buffer *buffer, 5037 struct hda_codec *codec, 5038 unsigned int verb) 5039 { 5040 snd_iprintf(buffer, "Analog Loopback: 0x%02x\n", 5041 snd_hda_codec_read(codec, codec->afg, 0, verb, 0)); 5042 } 5043 5044 /* stac92hd71bxx, stac92hd73xx */ 5045 static void stac92hd7x_proc_hook(struct snd_info_buffer *buffer, 5046 struct hda_codec *codec, hda_nid_t nid) 5047 { 5048 stac92hd_proc_hook(buffer, codec, nid); 5049 if (nid == codec->afg) 5050 analog_loop_proc_hook(buffer, codec, 0xfa0); 5051 } 5052 5053 static void stac9205_proc_hook(struct snd_info_buffer *buffer, 5054 struct hda_codec *codec, hda_nid_t nid) 5055 { 5056 if (nid == codec->afg) 5057 analog_loop_proc_hook(buffer, codec, 0xfe0); 5058 } 5059 5060 static void stac927x_proc_hook(struct snd_info_buffer *buffer, 5061 struct hda_codec *codec, hda_nid_t nid) 5062 { 5063 if (nid == codec->afg) 5064 analog_loop_proc_hook(buffer, codec, 0xfeb); 5065 } 5066 #else 5067 #define stac92hd_proc_hook NULL 5068 #define stac92hd7x_proc_hook NULL 5069 #define stac9205_proc_hook NULL 5070 #define stac927x_proc_hook NULL 5071 #endif 5072 5073 #ifdef CONFIG_PM 5074 static int stac92xx_resume(struct hda_codec *codec) 5075 { 5076 stac92xx_init(codec); 5077 snd_hda_codec_resume_amp(codec); 5078 snd_hda_codec_resume_cache(codec); 5079 /* fake event to set up pins again to override cached values */ 5080 stac_fake_hp_events(codec); 5081 return 0; 5082 } 5083 5084 static int stac92xx_suspend(struct hda_codec *codec) 5085 { 5086 stac92xx_shutup(codec); 5087 return 0; 5088 } 5089 5090 static void stac92xx_set_power_state(struct hda_codec *codec, hda_nid_t fg, 5091 unsigned int power_state) 5092 { 5093 unsigned int afg_power_state = power_state; 5094 struct sigmatel_spec *spec = codec->spec; 5095 5096 if (power_state == AC_PWRST_D3) { 5097 if (spec->vref_mute_led_nid) { 5098 /* with vref-out pin used for mute led control 5099 * codec AFG is prevented from D3 state 5100 */ 5101 afg_power_state = AC_PWRST_D1; 5102 } 5103 /* this delay seems necessary to avoid click noise at power-down */ 5104 msleep(100); 5105 } 5106 snd_hda_codec_read(codec, fg, 0, AC_VERB_SET_POWER_STATE, 5107 afg_power_state); 5108 snd_hda_codec_set_power_to_all(codec, fg, power_state, true); 5109 } 5110 #else 5111 #define stac92xx_suspend NULL 5112 #define stac92xx_resume NULL 5113 #define stac92xx_set_power_state NULL 5114 #endif /* CONFIG_PM */ 5115 5116 /* update mute-LED accoring to the master switch */ 5117 static void stac92xx_update_led_status(struct hda_codec *codec, int enabled) 5118 { 5119 struct sigmatel_spec *spec = codec->spec; 5120 int muted = !enabled; 5121 5122 if (!spec->gpio_led) 5123 return; 5124 5125 /* LED state is inverted on these systems */ 5126 if (spec->gpio_led_polarity) 5127 muted = !muted; 5128 5129 if (!spec->vref_mute_led_nid) { 5130 if (muted) 5131 spec->gpio_data |= spec->gpio_led; 5132 else 5133 spec->gpio_data &= ~spec->gpio_led; 5134 stac_gpio_set(codec, spec->gpio_mask, 5135 spec->gpio_dir, spec->gpio_data); 5136 } else { 5137 spec->vref_led = muted ? AC_PINCTL_VREF_50 : AC_PINCTL_VREF_GRD; 5138 stac_vrefout_set(codec, spec->vref_mute_led_nid, 5139 spec->vref_led); 5140 } 5141 } 5142 5143 static const struct hda_codec_ops stac92xx_patch_ops = { 5144 .build_controls = stac92xx_build_controls, 5145 .build_pcms = stac92xx_build_pcms, 5146 .init = stac92xx_init, 5147 .free = stac92xx_free, 5148 .unsol_event = snd_hda_jack_unsol_event, 5149 #ifdef CONFIG_PM 5150 .suspend = stac92xx_suspend, 5151 .resume = stac92xx_resume, 5152 #endif 5153 .reboot_notify = stac92xx_shutup, 5154 }; 5155 5156 static int patch_stac9200(struct hda_codec *codec) 5157 { 5158 struct sigmatel_spec *spec; 5159 int err; 5160 5161 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5162 if (spec == NULL) 5163 return -ENOMEM; 5164 5165 codec->no_trigger_sense = 1; 5166 codec->spec = spec; 5167 spec->linear_tone_beep = 1; 5168 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids); 5169 spec->pin_nids = stac9200_pin_nids; 5170 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS, 5171 stac9200_models, 5172 stac9200_cfg_tbl); 5173 if (spec->board_config < 0) 5174 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5175 codec->chip_name); 5176 else 5177 stac92xx_set_config_regs(codec, 5178 stac9200_brd_tbl[spec->board_config]); 5179 5180 spec->multiout.max_channels = 2; 5181 spec->multiout.num_dacs = 1; 5182 spec->multiout.dac_nids = stac9200_dac_nids; 5183 spec->adc_nids = stac9200_adc_nids; 5184 spec->mux_nids = stac9200_mux_nids; 5185 spec->num_muxes = 1; 5186 spec->num_dmics = 0; 5187 spec->num_adcs = 1; 5188 spec->num_pwrs = 0; 5189 5190 if (spec->board_config == STAC_9200_M4 || 5191 spec->board_config == STAC_9200_M4_2 || 5192 spec->board_config == STAC_9200_OQO) 5193 spec->init = stac9200_eapd_init; 5194 else 5195 spec->init = stac9200_core_init; 5196 spec->mixer = stac9200_mixer; 5197 5198 if (spec->board_config == STAC_9200_PANASONIC) { 5199 spec->gpio_mask = spec->gpio_dir = 0x09; 5200 spec->gpio_data = 0x00; 5201 } 5202 5203 err = stac9200_parse_auto_config(codec); 5204 if (err < 0) { 5205 stac92xx_free(codec); 5206 return err; 5207 } 5208 5209 /* CF-74 has no headphone detection, and the driver should *NOT* 5210 * do detection and HP/speaker toggle because the hardware does it. 5211 */ 5212 if (spec->board_config == STAC_9200_PANASONIC) 5213 spec->hp_detect = 0; 5214 5215 codec->patch_ops = stac92xx_patch_ops; 5216 5217 return 0; 5218 } 5219 5220 static int patch_stac925x(struct hda_codec *codec) 5221 { 5222 struct sigmatel_spec *spec; 5223 int err; 5224 5225 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5226 if (spec == NULL) 5227 return -ENOMEM; 5228 5229 codec->no_trigger_sense = 1; 5230 codec->spec = spec; 5231 spec->linear_tone_beep = 1; 5232 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids); 5233 spec->pin_nids = stac925x_pin_nids; 5234 5235 /* Check first for codec ID */ 5236 spec->board_config = snd_hda_check_board_codec_sid_config(codec, 5237 STAC_925x_MODELS, 5238 stac925x_models, 5239 stac925x_codec_id_cfg_tbl); 5240 5241 /* Now checks for PCI ID, if codec ID is not found */ 5242 if (spec->board_config < 0) 5243 spec->board_config = snd_hda_check_board_config(codec, 5244 STAC_925x_MODELS, 5245 stac925x_models, 5246 stac925x_cfg_tbl); 5247 again: 5248 if (spec->board_config < 0) 5249 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5250 codec->chip_name); 5251 else 5252 stac92xx_set_config_regs(codec, 5253 stac925x_brd_tbl[spec->board_config]); 5254 5255 spec->multiout.max_channels = 2; 5256 spec->multiout.num_dacs = 1; 5257 spec->multiout.dac_nids = stac925x_dac_nids; 5258 spec->adc_nids = stac925x_adc_nids; 5259 spec->mux_nids = stac925x_mux_nids; 5260 spec->num_muxes = 1; 5261 spec->num_adcs = 1; 5262 spec->num_pwrs = 0; 5263 switch (codec->vendor_id) { 5264 case 0x83847632: /* STAC9202 */ 5265 case 0x83847633: /* STAC9202D */ 5266 case 0x83847636: /* STAC9251 */ 5267 case 0x83847637: /* STAC9251D */ 5268 spec->num_dmics = STAC925X_NUM_DMICS; 5269 spec->dmic_nids = stac925x_dmic_nids; 5270 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids); 5271 spec->dmux_nids = stac925x_dmux_nids; 5272 break; 5273 default: 5274 spec->num_dmics = 0; 5275 break; 5276 } 5277 5278 spec->init = stac925x_core_init; 5279 spec->mixer = stac925x_mixer; 5280 spec->num_caps = 1; 5281 spec->capvols = stac925x_capvols; 5282 spec->capsws = stac925x_capsws; 5283 5284 err = stac92xx_parse_auto_config(codec); 5285 if (!err) { 5286 if (spec->board_config < 0) { 5287 printk(KERN_WARNING "hda_codec: No auto-config is " 5288 "available, default to model=ref\n"); 5289 spec->board_config = STAC_925x_REF; 5290 goto again; 5291 } 5292 err = -EINVAL; 5293 } 5294 if (err < 0) { 5295 stac92xx_free(codec); 5296 return err; 5297 } 5298 5299 codec->patch_ops = stac92xx_patch_ops; 5300 5301 return 0; 5302 } 5303 5304 static int patch_stac92hd73xx(struct hda_codec *codec) 5305 { 5306 struct sigmatel_spec *spec; 5307 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2]; 5308 int err = 0; 5309 int num_dacs; 5310 5311 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5312 if (spec == NULL) 5313 return -ENOMEM; 5314 5315 codec->no_trigger_sense = 1; 5316 codec->spec = spec; 5317 spec->linear_tone_beep = 0; 5318 codec->slave_dig_outs = stac92hd73xx_slave_dig_outs; 5319 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids); 5320 spec->pin_nids = stac92hd73xx_pin_nids; 5321 spec->board_config = snd_hda_check_board_config(codec, 5322 STAC_92HD73XX_MODELS, 5323 stac92hd73xx_models, 5324 stac92hd73xx_cfg_tbl); 5325 /* check codec subsystem id if not found */ 5326 if (spec->board_config < 0) 5327 spec->board_config = 5328 snd_hda_check_board_codec_sid_config(codec, 5329 STAC_92HD73XX_MODELS, stac92hd73xx_models, 5330 stac92hd73xx_codec_id_cfg_tbl); 5331 again: 5332 if (spec->board_config < 0) 5333 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5334 codec->chip_name); 5335 else 5336 stac92xx_set_config_regs(codec, 5337 stac92hd73xx_brd_tbl[spec->board_config]); 5338 5339 num_dacs = snd_hda_get_connections(codec, 0x0a, 5340 conn, STAC92HD73_DAC_COUNT + 2) - 1; 5341 5342 if (num_dacs < 3 || num_dacs > 5) { 5343 printk(KERN_WARNING "hda_codec: Could not determine " 5344 "number of channels defaulting to DAC count\n"); 5345 num_dacs = STAC92HD73_DAC_COUNT; 5346 } 5347 spec->init = stac92hd73xx_core_init; 5348 switch (num_dacs) { 5349 case 0x3: /* 6 Channel */ 5350 spec->aloopback_ctl = stac92hd73xx_6ch_loopback; 5351 break; 5352 case 0x4: /* 8 Channel */ 5353 spec->aloopback_ctl = stac92hd73xx_8ch_loopback; 5354 break; 5355 case 0x5: /* 10 Channel */ 5356 spec->aloopback_ctl = stac92hd73xx_10ch_loopback; 5357 break; 5358 } 5359 spec->multiout.dac_nids = spec->dac_nids; 5360 5361 spec->aloopback_mask = 0x01; 5362 spec->aloopback_shift = 8; 5363 5364 spec->digbeep_nid = 0x1c; 5365 spec->mux_nids = stac92hd73xx_mux_nids; 5366 spec->adc_nids = stac92hd73xx_adc_nids; 5367 spec->dmic_nids = stac92hd73xx_dmic_nids; 5368 spec->dmux_nids = stac92hd73xx_dmux_nids; 5369 spec->smux_nids = stac92hd73xx_smux_nids; 5370 5371 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids); 5372 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids); 5373 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids); 5374 5375 spec->num_caps = STAC92HD73XX_NUM_CAPS; 5376 spec->capvols = stac92hd73xx_capvols; 5377 spec->capsws = stac92hd73xx_capsws; 5378 5379 switch (spec->board_config) { 5380 case STAC_DELL_EQ: 5381 spec->init = dell_eq_core_init; 5382 /* fallthru */ 5383 case STAC_DELL_M6_AMIC: 5384 case STAC_DELL_M6_DMIC: 5385 case STAC_DELL_M6_BOTH: 5386 spec->num_smuxes = 0; 5387 spec->eapd_switch = 0; 5388 5389 switch (spec->board_config) { 5390 case STAC_DELL_M6_AMIC: /* Analog Mics */ 5391 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5392 spec->num_dmics = 0; 5393 break; 5394 case STAC_DELL_M6_DMIC: /* Digital Mics */ 5395 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5396 spec->num_dmics = 1; 5397 break; 5398 case STAC_DELL_M6_BOTH: /* Both */ 5399 snd_hda_codec_set_pincfg(codec, 0x0b, 0x90A70170); 5400 snd_hda_codec_set_pincfg(codec, 0x13, 0x90A60160); 5401 spec->num_dmics = 1; 5402 break; 5403 } 5404 break; 5405 case STAC_ALIENWARE_M17X: 5406 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5407 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5408 spec->eapd_switch = 0; 5409 break; 5410 default: 5411 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 5412 spec->num_smuxes = ARRAY_SIZE(stac92hd73xx_smux_nids); 5413 spec->eapd_switch = 1; 5414 break; 5415 } 5416 if (spec->board_config != STAC_92HD73XX_REF) { 5417 /* GPIO0 High = Enable EAPD */ 5418 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 5419 spec->gpio_data = 0x01; 5420 } 5421 5422 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids); 5423 spec->pwr_nids = stac92hd73xx_pwr_nids; 5424 5425 err = stac92xx_parse_auto_config(codec); 5426 5427 if (!err) { 5428 if (spec->board_config < 0) { 5429 printk(KERN_WARNING "hda_codec: No auto-config is " 5430 "available, default to model=ref\n"); 5431 spec->board_config = STAC_92HD73XX_REF; 5432 goto again; 5433 } 5434 err = -EINVAL; 5435 } 5436 5437 if (err < 0) { 5438 stac92xx_free(codec); 5439 return err; 5440 } 5441 5442 if (spec->board_config == STAC_92HD73XX_NO_JD) 5443 spec->hp_detect = 0; 5444 5445 codec->patch_ops = stac92xx_patch_ops; 5446 5447 codec->proc_widget_hook = stac92hd7x_proc_hook; 5448 5449 return 0; 5450 } 5451 5452 static int hp_bnb2011_with_dock(struct hda_codec *codec) 5453 { 5454 if (codec->vendor_id != 0x111d7605 && 5455 codec->vendor_id != 0x111d76d1) 5456 return 0; 5457 5458 switch (codec->subsystem_id) { 5459 case 0x103c1618: 5460 case 0x103c1619: 5461 case 0x103c161a: 5462 case 0x103c161b: 5463 case 0x103c161c: 5464 case 0x103c161d: 5465 case 0x103c161e: 5466 case 0x103c161f: 5467 5468 case 0x103c162a: 5469 case 0x103c162b: 5470 5471 case 0x103c1630: 5472 case 0x103c1631: 5473 5474 case 0x103c1633: 5475 case 0x103c1634: 5476 case 0x103c1635: 5477 5478 case 0x103c3587: 5479 case 0x103c3588: 5480 case 0x103c3589: 5481 case 0x103c358a: 5482 5483 case 0x103c3667: 5484 case 0x103c3668: 5485 case 0x103c3669: 5486 5487 return 1; 5488 } 5489 return 0; 5490 } 5491 5492 static void stac92hd8x_add_pin(struct hda_codec *codec, hda_nid_t nid) 5493 { 5494 struct sigmatel_spec *spec = codec->spec; 5495 unsigned int def_conf = snd_hda_codec_get_pincfg(codec, nid); 5496 int i; 5497 5498 spec->auto_pin_nids[spec->auto_pin_cnt] = nid; 5499 spec->auto_pin_cnt++; 5500 5501 if (get_defcfg_device(def_conf) == AC_JACK_MIC_IN && 5502 get_defcfg_connect(def_conf) != AC_JACK_PORT_NONE) { 5503 for (i = 0; i < ARRAY_SIZE(stac92hd83xxx_dmic_nids); i++) { 5504 if (nid == stac92hd83xxx_dmic_nids[i]) { 5505 spec->auto_dmic_nids[spec->auto_dmic_cnt] = nid; 5506 spec->auto_dmic_cnt++; 5507 } 5508 } 5509 } 5510 } 5511 5512 static void stac92hd8x_add_adc(struct hda_codec *codec, hda_nid_t nid) 5513 { 5514 struct sigmatel_spec *spec = codec->spec; 5515 5516 spec->auto_adc_nids[spec->auto_adc_cnt] = nid; 5517 spec->auto_adc_cnt++; 5518 } 5519 5520 static void stac92hd8x_add_mux(struct hda_codec *codec, hda_nid_t nid) 5521 { 5522 int i, j; 5523 struct sigmatel_spec *spec = codec->spec; 5524 5525 for (i = 0; i < spec->auto_adc_cnt; i++) { 5526 if (get_connection_index(codec, 5527 spec->auto_adc_nids[i], nid) >= 0) { 5528 /* mux and volume for adc_nids[i] */ 5529 if (!spec->auto_mux_nids[i]) { 5530 spec->auto_mux_nids[i] = nid; 5531 /* 92hd codecs capture volume is in mux */ 5532 spec->auto_capvols[i] = HDA_COMPOSE_AMP_VAL(nid, 5533 3, 0, HDA_OUTPUT); 5534 } 5535 for (j = 0; j < spec->auto_dmic_cnt; j++) { 5536 if (get_connection_index(codec, nid, 5537 spec->auto_dmic_nids[j]) >= 0) { 5538 /* dmux for adc_nids[i] */ 5539 if (!spec->auto_dmux_nids[i]) 5540 spec->auto_dmux_nids[i] = nid; 5541 break; 5542 } 5543 } 5544 break; 5545 } 5546 } 5547 } 5548 5549 static void stac92hd8x_fill_auto_spec(struct hda_codec *codec) 5550 { 5551 hda_nid_t nid, end_nid; 5552 unsigned int wid_caps, wid_type; 5553 struct sigmatel_spec *spec = codec->spec; 5554 5555 end_nid = codec->start_nid + codec->num_nodes; 5556 5557 for (nid = codec->start_nid; nid < end_nid; nid++) { 5558 wid_caps = get_wcaps(codec, nid); 5559 wid_type = get_wcaps_type(wid_caps); 5560 5561 if (wid_type == AC_WID_PIN) 5562 stac92hd8x_add_pin(codec, nid); 5563 5564 if (wid_type == AC_WID_AUD_IN && !(wid_caps & AC_WCAP_DIGITAL)) 5565 stac92hd8x_add_adc(codec, nid); 5566 } 5567 5568 for (nid = codec->start_nid; nid < end_nid; nid++) { 5569 wid_caps = get_wcaps(codec, nid); 5570 wid_type = get_wcaps_type(wid_caps); 5571 5572 if (wid_type == AC_WID_AUD_SEL) 5573 stac92hd8x_add_mux(codec, nid); 5574 } 5575 5576 spec->pin_nids = spec->auto_pin_nids; 5577 spec->num_pins = spec->auto_pin_cnt; 5578 spec->adc_nids = spec->auto_adc_nids; 5579 spec->num_adcs = spec->auto_adc_cnt; 5580 spec->capvols = spec->auto_capvols; 5581 spec->capsws = spec->auto_capvols; 5582 spec->num_caps = spec->auto_adc_cnt; 5583 spec->mux_nids = spec->auto_mux_nids; 5584 spec->num_muxes = spec->auto_adc_cnt; 5585 spec->dmux_nids = spec->auto_dmux_nids; 5586 spec->num_dmuxes = spec->auto_adc_cnt; 5587 spec->dmic_nids = spec->auto_dmic_nids; 5588 spec->num_dmics = spec->auto_dmic_cnt; 5589 } 5590 5591 static int patch_stac92hd83xxx(struct hda_codec *codec) 5592 { 5593 struct sigmatel_spec *spec; 5594 int default_polarity = -1; /* no default cfg */ 5595 int err; 5596 5597 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5598 if (spec == NULL) 5599 return -ENOMEM; 5600 5601 if (hp_bnb2011_with_dock(codec)) { 5602 snd_hda_codec_set_pincfg(codec, 0xa, 0x2101201f); 5603 snd_hda_codec_set_pincfg(codec, 0xf, 0x2181205e); 5604 } 5605 5606 codec->epss = 0; /* longer delay needed for D3 */ 5607 codec->no_trigger_sense = 1; 5608 codec->spec = spec; 5609 5610 stac92hd8x_fill_auto_spec(codec); 5611 5612 spec->linear_tone_beep = 0; 5613 codec->slave_dig_outs = stac92hd83xxx_slave_dig_outs; 5614 spec->digbeep_nid = 0x21; 5615 spec->pwr_nids = stac92hd83xxx_pwr_nids; 5616 spec->num_pwrs = ARRAY_SIZE(stac92hd83xxx_pwr_nids); 5617 spec->multiout.dac_nids = spec->dac_nids; 5618 spec->init = stac92hd83xxx_core_init; 5619 5620 spec->board_config = snd_hda_check_board_config(codec, 5621 STAC_92HD83XXX_MODELS, 5622 stac92hd83xxx_models, 5623 stac92hd83xxx_cfg_tbl); 5624 /* check codec subsystem id if not found */ 5625 if (spec->board_config < 0) 5626 spec->board_config = 5627 snd_hda_check_board_codec_sid_config(codec, 5628 STAC_92HD83XXX_MODELS, stac92hd83xxx_models, 5629 stac92hd83xxx_codec_id_cfg_tbl); 5630 again: 5631 if (spec->board_config < 0) 5632 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5633 codec->chip_name); 5634 else 5635 stac92xx_set_config_regs(codec, 5636 stac92hd83xxx_brd_tbl[spec->board_config]); 5637 5638 codec->patch_ops = stac92xx_patch_ops; 5639 5640 switch (spec->board_config) { 5641 case STAC_HP_ZEPHYR: 5642 spec->init = stac92hd83xxx_hp_zephyr_init; 5643 break; 5644 case STAC_92HD83XXX_HP_LED: 5645 default_polarity = 0; 5646 break; 5647 case STAC_92HD83XXX_HP_INV_LED: 5648 default_polarity = 1; 5649 break; 5650 case STAC_92HD83XXX_HP_MIC_LED: 5651 spec->mic_mute_led_gpio = 0x08; /* GPIO3 */ 5652 break; 5653 case STAC_92HD83XXX_HEADSET_JACK: 5654 spec->headset_jack = 1; 5655 break; 5656 } 5657 5658 if (find_mute_led_cfg(codec, default_polarity)) 5659 snd_printd("mute LED gpio %d polarity %d\n", 5660 spec->gpio_led, 5661 spec->gpio_led_polarity); 5662 5663 if (spec->gpio_led) { 5664 if (!spec->vref_mute_led_nid) { 5665 spec->gpio_mask |= spec->gpio_led; 5666 spec->gpio_dir |= spec->gpio_led; 5667 spec->gpio_data |= spec->gpio_led; 5668 } else { 5669 codec->patch_ops.set_power_state = 5670 stac92xx_set_power_state; 5671 } 5672 } 5673 5674 if (spec->mic_mute_led_gpio) { 5675 spec->gpio_mask |= spec->mic_mute_led_gpio; 5676 spec->gpio_dir |= spec->mic_mute_led_gpio; 5677 spec->mic_mute_led_on = true; 5678 spec->gpio_data |= spec->mic_mute_led_gpio; 5679 } 5680 5681 err = stac92xx_parse_auto_config(codec); 5682 if (!err) { 5683 if (spec->board_config < 0) { 5684 printk(KERN_WARNING "hda_codec: No auto-config is " 5685 "available, default to model=ref\n"); 5686 spec->board_config = STAC_92HD83XXX_REF; 5687 goto again; 5688 } 5689 err = -EINVAL; 5690 } 5691 5692 if (err < 0) { 5693 stac92xx_free(codec); 5694 return err; 5695 } 5696 5697 codec->proc_widget_hook = stac92hd_proc_hook; 5698 5699 return 0; 5700 } 5701 5702 static int stac92hd71bxx_connected_smuxes(struct hda_codec *codec, 5703 hda_nid_t dig0pin) 5704 { 5705 struct sigmatel_spec *spec = codec->spec; 5706 int idx; 5707 5708 for (idx = 0; idx < spec->num_pins; idx++) 5709 if (spec->pin_nids[idx] == dig0pin) 5710 break; 5711 if ((idx + 2) >= spec->num_pins) 5712 return 0; 5713 5714 /* dig1pin case */ 5715 if (stac_get_defcfg_connect(codec, idx + 1) != AC_JACK_PORT_NONE) 5716 return 2; 5717 5718 /* dig0pin + dig2pin case */ 5719 if (stac_get_defcfg_connect(codec, idx + 2) != AC_JACK_PORT_NONE) 5720 return 2; 5721 if (stac_get_defcfg_connect(codec, idx) != AC_JACK_PORT_NONE) 5722 return 1; 5723 else 5724 return 0; 5725 } 5726 5727 /* HP dv7 bass switch - GPIO5 */ 5728 #define stac_hp_bass_gpio_info snd_ctl_boolean_mono_info 5729 static int stac_hp_bass_gpio_get(struct snd_kcontrol *kcontrol, 5730 struct snd_ctl_elem_value *ucontrol) 5731 { 5732 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5733 struct sigmatel_spec *spec = codec->spec; 5734 ucontrol->value.integer.value[0] = !!(spec->gpio_data & 0x20); 5735 return 0; 5736 } 5737 5738 static int stac_hp_bass_gpio_put(struct snd_kcontrol *kcontrol, 5739 struct snd_ctl_elem_value *ucontrol) 5740 { 5741 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 5742 struct sigmatel_spec *spec = codec->spec; 5743 unsigned int gpio_data; 5744 5745 gpio_data = (spec->gpio_data & ~0x20) | 5746 (ucontrol->value.integer.value[0] ? 0x20 : 0); 5747 if (gpio_data == spec->gpio_data) 5748 return 0; 5749 spec->gpio_data = gpio_data; 5750 stac_gpio_set(codec, spec->gpio_mask, spec->gpio_dir, spec->gpio_data); 5751 return 1; 5752 } 5753 5754 static const struct snd_kcontrol_new stac_hp_bass_sw_ctrl = { 5755 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 5756 .info = stac_hp_bass_gpio_info, 5757 .get = stac_hp_bass_gpio_get, 5758 .put = stac_hp_bass_gpio_put, 5759 }; 5760 5761 static int stac_add_hp_bass_switch(struct hda_codec *codec) 5762 { 5763 struct sigmatel_spec *spec = codec->spec; 5764 5765 if (!stac_control_new(spec, &stac_hp_bass_sw_ctrl, 5766 "Bass Speaker Playback Switch", 0)) 5767 return -ENOMEM; 5768 5769 spec->gpio_mask |= 0x20; 5770 spec->gpio_dir |= 0x20; 5771 spec->gpio_data |= 0x20; 5772 return 0; 5773 } 5774 5775 static int patch_stac92hd71bxx(struct hda_codec *codec) 5776 { 5777 struct sigmatel_spec *spec; 5778 const struct hda_verb *unmute_init = stac92hd71bxx_unmute_core_init; 5779 unsigned int pin_cfg; 5780 int err = 0; 5781 5782 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 5783 if (spec == NULL) 5784 return -ENOMEM; 5785 5786 codec->no_trigger_sense = 1; 5787 codec->spec = spec; 5788 spec->linear_tone_beep = 0; 5789 codec->patch_ops = stac92xx_patch_ops; 5790 spec->num_pins = STAC92HD71BXX_NUM_PINS; 5791 switch (codec->vendor_id) { 5792 case 0x111d76b6: 5793 case 0x111d76b7: 5794 spec->pin_nids = stac92hd71bxx_pin_nids_4port; 5795 break; 5796 case 0x111d7603: 5797 case 0x111d7608: 5798 /* On 92HD75Bx 0x27 isn't a pin nid */ 5799 spec->num_pins--; 5800 /* fallthrough */ 5801 default: 5802 spec->pin_nids = stac92hd71bxx_pin_nids_6port; 5803 } 5804 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids); 5805 spec->board_config = snd_hda_check_board_config(codec, 5806 STAC_92HD71BXX_MODELS, 5807 stac92hd71bxx_models, 5808 stac92hd71bxx_cfg_tbl); 5809 again: 5810 if (spec->board_config < 0) 5811 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 5812 codec->chip_name); 5813 else 5814 stac92xx_set_config_regs(codec, 5815 stac92hd71bxx_brd_tbl[spec->board_config]); 5816 5817 if (spec->board_config != STAC_92HD71BXX_REF) { 5818 /* GPIO0 = EAPD */ 5819 spec->gpio_mask = 0x01; 5820 spec->gpio_dir = 0x01; 5821 spec->gpio_data = 0x01; 5822 } 5823 5824 spec->dmic_nids = stac92hd71bxx_dmic_nids; 5825 spec->dmux_nids = stac92hd71bxx_dmux_nids; 5826 5827 spec->num_caps = STAC92HD71BXX_NUM_CAPS; 5828 spec->capvols = stac92hd71bxx_capvols; 5829 spec->capsws = stac92hd71bxx_capsws; 5830 5831 switch (codec->vendor_id) { 5832 case 0x111d76b6: /* 4 Port without Analog Mixer */ 5833 case 0x111d76b7: 5834 unmute_init++; 5835 /* fallthru */ 5836 case 0x111d76b4: /* 6 Port without Analog Mixer */ 5837 case 0x111d76b5: 5838 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5839 spec->num_dmics = stac92xx_connected_ports(codec, 5840 stac92hd71bxx_dmic_nids, 5841 STAC92HD71BXX_NUM_DMICS); 5842 break; 5843 case 0x111d7608: /* 5 Port with Analog Mixer */ 5844 switch (spec->board_config) { 5845 case STAC_HP_M4: 5846 /* Enable VREF power saving on GPIO1 detect */ 5847 err = stac_add_event(codec, codec->afg, 5848 STAC_VREF_EVENT, 0x02); 5849 if (err < 0) 5850 return err; 5851 snd_hda_codec_write_cache(codec, codec->afg, 0, 5852 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x02); 5853 snd_hda_jack_detect_enable(codec, codec->afg, 0); 5854 spec->gpio_mask |= 0x02; 5855 break; 5856 } 5857 if ((codec->revision_id & 0xf) == 0 || 5858 (codec->revision_id & 0xf) == 1) 5859 spec->stream_delay = 40; /* 40 milliseconds */ 5860 5861 /* disable VSW */ 5862 unmute_init++; 5863 snd_hda_codec_set_pincfg(codec, 0x0f, 0x40f000f0); 5864 snd_hda_codec_set_pincfg(codec, 0x19, 0x40f000f3); 5865 spec->dmic_nids = stac92hd71bxx_dmic_5port_nids; 5866 spec->num_dmics = stac92xx_connected_ports(codec, 5867 stac92hd71bxx_dmic_5port_nids, 5868 STAC92HD71BXX_NUM_DMICS - 1); 5869 break; 5870 case 0x111d7603: /* 6 Port with Analog Mixer */ 5871 if ((codec->revision_id & 0xf) == 1) 5872 spec->stream_delay = 40; /* 40 milliseconds */ 5873 5874 /* fallthru */ 5875 default: 5876 codec->slave_dig_outs = stac92hd71bxx_slave_dig_outs; 5877 spec->num_dmics = stac92xx_connected_ports(codec, 5878 stac92hd71bxx_dmic_nids, 5879 STAC92HD71BXX_NUM_DMICS); 5880 break; 5881 } 5882 5883 if (get_wcaps_type(get_wcaps(codec, 0x28)) == AC_WID_VOL_KNB) 5884 spec->init = stac92hd71bxx_core_init; 5885 5886 if (get_wcaps(codec, 0xa) & AC_WCAP_IN_AMP) 5887 snd_hda_sequence_write_cache(codec, unmute_init); 5888 5889 spec->aloopback_ctl = stac92hd71bxx_loopback; 5890 spec->aloopback_mask = 0x50; 5891 spec->aloopback_shift = 0; 5892 5893 spec->powerdown_adcs = 1; 5894 spec->digbeep_nid = 0x26; 5895 spec->mux_nids = stac92hd71bxx_mux_nids; 5896 spec->adc_nids = stac92hd71bxx_adc_nids; 5897 spec->smux_nids = stac92hd71bxx_smux_nids; 5898 spec->pwr_nids = stac92hd71bxx_pwr_nids; 5899 5900 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids); 5901 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids); 5902 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids); 5903 spec->num_smuxes = stac92hd71bxx_connected_smuxes(codec, 0x1e); 5904 5905 snd_printdd("Found board config: %d\n", spec->board_config); 5906 5907 switch (spec->board_config) { 5908 case STAC_HP_M4: 5909 /* enable internal microphone */ 5910 snd_hda_codec_set_pincfg(codec, 0x0e, 0x01813040); 5911 stac92xx_auto_set_pinctl(codec, 0x0e, 5912 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80); 5913 /* fallthru */ 5914 case STAC_DELL_M4_2: 5915 spec->num_dmics = 0; 5916 spec->num_smuxes = 0; 5917 spec->num_dmuxes = 0; 5918 break; 5919 case STAC_DELL_M4_1: 5920 case STAC_DELL_M4_3: 5921 spec->num_dmics = 1; 5922 spec->num_smuxes = 0; 5923 spec->num_dmuxes = 1; 5924 break; 5925 case STAC_HP_DV4_1222NR: 5926 spec->num_dmics = 1; 5927 /* I don't know if it needs 1 or 2 smuxes - will wait for 5928 * bug reports to fix if needed 5929 */ 5930 spec->num_smuxes = 1; 5931 spec->num_dmuxes = 1; 5932 /* fallthrough */ 5933 case STAC_HP_DV4: 5934 spec->gpio_led = 0x01; 5935 /* fallthrough */ 5936 case STAC_HP_DV5: 5937 snd_hda_codec_set_pincfg(codec, 0x0d, 0x90170010); 5938 stac92xx_auto_set_pinctl(codec, 0x0d, AC_PINCTL_OUT_EN); 5939 /* HP dv6 gives the headphone pin as a line-out. Thus we 5940 * need to set hp_detect flag here to force to enable HP 5941 * detection. 5942 */ 5943 spec->hp_detect = 1; 5944 break; 5945 case STAC_HP_HDX: 5946 spec->num_dmics = 1; 5947 spec->num_dmuxes = 1; 5948 spec->num_smuxes = 1; 5949 spec->gpio_led = 0x08; 5950 break; 5951 } 5952 5953 if (hp_blike_system(codec->subsystem_id)) { 5954 pin_cfg = snd_hda_codec_get_pincfg(codec, 0x0f); 5955 if (get_defcfg_device(pin_cfg) == AC_JACK_LINE_OUT || 5956 get_defcfg_device(pin_cfg) == AC_JACK_SPEAKER || 5957 get_defcfg_device(pin_cfg) == AC_JACK_HP_OUT) { 5958 /* It was changed in the BIOS to just satisfy MS DTM. 5959 * Lets turn it back into slaved HP 5960 */ 5961 pin_cfg = (pin_cfg & (~AC_DEFCFG_DEVICE)) 5962 | (AC_JACK_HP_OUT << 5963 AC_DEFCFG_DEVICE_SHIFT); 5964 pin_cfg = (pin_cfg & (~(AC_DEFCFG_DEF_ASSOC 5965 | AC_DEFCFG_SEQUENCE))) 5966 | 0x1f; 5967 snd_hda_codec_set_pincfg(codec, 0x0f, pin_cfg); 5968 } 5969 } 5970 5971 if (find_mute_led_cfg(codec, 1)) 5972 snd_printd("mute LED gpio %d polarity %d\n", 5973 spec->gpio_led, 5974 spec->gpio_led_polarity); 5975 5976 if (spec->gpio_led) { 5977 if (!spec->vref_mute_led_nid) { 5978 spec->gpio_mask |= spec->gpio_led; 5979 spec->gpio_dir |= spec->gpio_led; 5980 spec->gpio_data |= spec->gpio_led; 5981 } else { 5982 codec->patch_ops.set_power_state = 5983 stac92xx_set_power_state; 5984 } 5985 } 5986 5987 spec->multiout.dac_nids = spec->dac_nids; 5988 5989 err = stac92xx_parse_auto_config(codec); 5990 if (!err) { 5991 if (spec->board_config < 0) { 5992 printk(KERN_WARNING "hda_codec: No auto-config is " 5993 "available, default to model=ref\n"); 5994 spec->board_config = STAC_92HD71BXX_REF; 5995 goto again; 5996 } 5997 err = -EINVAL; 5998 } 5999 6000 if (err < 0) { 6001 stac92xx_free(codec); 6002 return err; 6003 } 6004 6005 /* enable bass on HP dv7 */ 6006 if (spec->board_config == STAC_HP_DV4 || 6007 spec->board_config == STAC_HP_DV5) { 6008 unsigned int cap; 6009 cap = snd_hda_param_read(codec, 0x1, AC_PAR_GPIO_CAP); 6010 cap &= AC_GPIO_IO_COUNT; 6011 if (cap >= 6) 6012 stac_add_hp_bass_switch(codec); 6013 } 6014 6015 codec->proc_widget_hook = stac92hd7x_proc_hook; 6016 6017 return 0; 6018 } 6019 6020 static int patch_stac922x(struct hda_codec *codec) 6021 { 6022 struct sigmatel_spec *spec; 6023 int err; 6024 6025 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6026 if (spec == NULL) 6027 return -ENOMEM; 6028 6029 codec->no_trigger_sense = 1; 6030 codec->spec = spec; 6031 spec->linear_tone_beep = 1; 6032 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids); 6033 spec->pin_nids = stac922x_pin_nids; 6034 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS, 6035 stac922x_models, 6036 stac922x_cfg_tbl); 6037 if (spec->board_config == STAC_INTEL_MAC_AUTO) { 6038 spec->gpio_mask = spec->gpio_dir = 0x03; 6039 spec->gpio_data = 0x03; 6040 /* Intel Macs have all same PCI SSID, so we need to check 6041 * codec SSID to distinguish the exact models 6042 */ 6043 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id); 6044 switch (codec->subsystem_id) { 6045 6046 case 0x106b0800: 6047 spec->board_config = STAC_INTEL_MAC_V1; 6048 break; 6049 case 0x106b0600: 6050 case 0x106b0700: 6051 spec->board_config = STAC_INTEL_MAC_V2; 6052 break; 6053 case 0x106b0e00: 6054 case 0x106b0f00: 6055 case 0x106b1600: 6056 case 0x106b1700: 6057 case 0x106b0200: 6058 case 0x106b1e00: 6059 spec->board_config = STAC_INTEL_MAC_V3; 6060 break; 6061 case 0x106b1a00: 6062 case 0x00000100: 6063 spec->board_config = STAC_INTEL_MAC_V4; 6064 break; 6065 case 0x106b0a00: 6066 case 0x106b2200: 6067 spec->board_config = STAC_INTEL_MAC_V5; 6068 break; 6069 default: 6070 spec->board_config = STAC_INTEL_MAC_V3; 6071 break; 6072 } 6073 } 6074 6075 again: 6076 if (spec->board_config < 0) 6077 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6078 codec->chip_name); 6079 else 6080 stac92xx_set_config_regs(codec, 6081 stac922x_brd_tbl[spec->board_config]); 6082 6083 spec->adc_nids = stac922x_adc_nids; 6084 spec->mux_nids = stac922x_mux_nids; 6085 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids); 6086 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids); 6087 spec->num_dmics = 0; 6088 spec->num_pwrs = 0; 6089 6090 spec->init = stac922x_core_init; 6091 6092 spec->num_caps = STAC922X_NUM_CAPS; 6093 spec->capvols = stac922x_capvols; 6094 spec->capsws = stac922x_capsws; 6095 6096 spec->multiout.dac_nids = spec->dac_nids; 6097 6098 err = stac92xx_parse_auto_config(codec); 6099 if (!err) { 6100 if (spec->board_config < 0) { 6101 printk(KERN_WARNING "hda_codec: No auto-config is " 6102 "available, default to model=ref\n"); 6103 spec->board_config = STAC_D945_REF; 6104 goto again; 6105 } 6106 err = -EINVAL; 6107 } 6108 if (err < 0) { 6109 stac92xx_free(codec); 6110 return err; 6111 } 6112 6113 codec->patch_ops = stac92xx_patch_ops; 6114 6115 /* Fix Mux capture level; max to 2 */ 6116 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT, 6117 (0 << AC_AMPCAP_OFFSET_SHIFT) | 6118 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) | 6119 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) | 6120 (0 << AC_AMPCAP_MUTE_SHIFT)); 6121 6122 return 0; 6123 } 6124 6125 static int patch_stac927x(struct hda_codec *codec) 6126 { 6127 struct sigmatel_spec *spec; 6128 int err; 6129 6130 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6131 if (spec == NULL) 6132 return -ENOMEM; 6133 6134 codec->no_trigger_sense = 1; 6135 codec->spec = spec; 6136 spec->linear_tone_beep = 1; 6137 codec->slave_dig_outs = stac927x_slave_dig_outs; 6138 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids); 6139 spec->pin_nids = stac927x_pin_nids; 6140 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS, 6141 stac927x_models, 6142 stac927x_cfg_tbl); 6143 again: 6144 if (spec->board_config < 0) 6145 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6146 codec->chip_name); 6147 else 6148 stac92xx_set_config_regs(codec, 6149 stac927x_brd_tbl[spec->board_config]); 6150 6151 spec->digbeep_nid = 0x23; 6152 spec->adc_nids = stac927x_adc_nids; 6153 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids); 6154 spec->mux_nids = stac927x_mux_nids; 6155 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids); 6156 spec->smux_nids = stac927x_smux_nids; 6157 spec->num_smuxes = ARRAY_SIZE(stac927x_smux_nids); 6158 spec->spdif_labels = stac927x_spdif_labels; 6159 spec->dac_list = stac927x_dac_nids; 6160 spec->multiout.dac_nids = spec->dac_nids; 6161 6162 if (spec->board_config != STAC_D965_REF) { 6163 /* GPIO0 High = Enable EAPD */ 6164 spec->eapd_mask = spec->gpio_mask = 0x01; 6165 spec->gpio_dir = spec->gpio_data = 0x01; 6166 } 6167 6168 switch (spec->board_config) { 6169 case STAC_D965_3ST: 6170 case STAC_D965_5ST: 6171 /* GPIO0 High = Enable EAPD */ 6172 spec->num_dmics = 0; 6173 spec->init = d965_core_init; 6174 break; 6175 case STAC_DELL_BIOS: 6176 switch (codec->subsystem_id) { 6177 case 0x10280209: 6178 case 0x1028022e: 6179 /* correct the device field to SPDIF out */ 6180 snd_hda_codec_set_pincfg(codec, 0x21, 0x01442070); 6181 break; 6182 } 6183 /* configure the analog microphone on some laptops */ 6184 snd_hda_codec_set_pincfg(codec, 0x0c, 0x90a79130); 6185 /* correct the front output jack as a hp out */ 6186 snd_hda_codec_set_pincfg(codec, 0x0f, 0x0227011f); 6187 /* correct the front input jack as a mic */ 6188 snd_hda_codec_set_pincfg(codec, 0x0e, 0x02a79130); 6189 /* fallthru */ 6190 case STAC_DELL_3ST: 6191 if (codec->subsystem_id != 0x1028022f) { 6192 /* GPIO2 High = Enable EAPD */ 6193 spec->eapd_mask = spec->gpio_mask = 0x04; 6194 spec->gpio_dir = spec->gpio_data = 0x04; 6195 } 6196 spec->dmic_nids = stac927x_dmic_nids; 6197 spec->num_dmics = STAC927X_NUM_DMICS; 6198 6199 spec->init = dell_3st_core_init; 6200 spec->dmux_nids = stac927x_dmux_nids; 6201 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids); 6202 break; 6203 case STAC_927X_VOLKNOB: 6204 spec->num_dmics = 0; 6205 spec->init = stac927x_volknob_core_init; 6206 break; 6207 default: 6208 spec->num_dmics = 0; 6209 spec->init = stac927x_core_init; 6210 break; 6211 } 6212 6213 spec->num_caps = STAC927X_NUM_CAPS; 6214 spec->capvols = stac927x_capvols; 6215 spec->capsws = stac927x_capsws; 6216 6217 spec->num_pwrs = 0; 6218 spec->aloopback_ctl = stac927x_loopback; 6219 spec->aloopback_mask = 0x40; 6220 spec->aloopback_shift = 0; 6221 spec->eapd_switch = 1; 6222 6223 err = stac92xx_parse_auto_config(codec); 6224 if (!err) { 6225 if (spec->board_config < 0) { 6226 printk(KERN_WARNING "hda_codec: No auto-config is " 6227 "available, default to model=ref\n"); 6228 spec->board_config = STAC_D965_REF; 6229 goto again; 6230 } 6231 err = -EINVAL; 6232 } 6233 if (err < 0) { 6234 stac92xx_free(codec); 6235 return err; 6236 } 6237 6238 codec->patch_ops = stac92xx_patch_ops; 6239 6240 codec->proc_widget_hook = stac927x_proc_hook; 6241 6242 /* 6243 * !!FIXME!! 6244 * The STAC927x seem to require fairly long delays for certain 6245 * command sequences. With too short delays (even if the answer 6246 * is set to RIRB properly), it results in the silence output 6247 * on some hardwares like Dell. 6248 * 6249 * The below flag enables the longer delay (see get_response 6250 * in hda_intel.c). 6251 */ 6252 codec->bus->needs_damn_long_delay = 1; 6253 6254 /* no jack detecion for ref-no-jd model */ 6255 if (spec->board_config == STAC_D965_REF_NO_JD) 6256 spec->hp_detect = 0; 6257 6258 return 0; 6259 } 6260 6261 static int patch_stac9205(struct hda_codec *codec) 6262 { 6263 struct sigmatel_spec *spec; 6264 int err; 6265 6266 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6267 if (spec == NULL) 6268 return -ENOMEM; 6269 6270 codec->no_trigger_sense = 1; 6271 codec->spec = spec; 6272 spec->linear_tone_beep = 1; 6273 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids); 6274 spec->pin_nids = stac9205_pin_nids; 6275 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS, 6276 stac9205_models, 6277 stac9205_cfg_tbl); 6278 again: 6279 if (spec->board_config < 0) 6280 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6281 codec->chip_name); 6282 else 6283 stac92xx_set_config_regs(codec, 6284 stac9205_brd_tbl[spec->board_config]); 6285 6286 spec->digbeep_nid = 0x23; 6287 spec->adc_nids = stac9205_adc_nids; 6288 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids); 6289 spec->mux_nids = stac9205_mux_nids; 6290 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids); 6291 spec->smux_nids = stac9205_smux_nids; 6292 spec->num_smuxes = ARRAY_SIZE(stac9205_smux_nids); 6293 spec->dmic_nids = stac9205_dmic_nids; 6294 spec->num_dmics = STAC9205_NUM_DMICS; 6295 spec->dmux_nids = stac9205_dmux_nids; 6296 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids); 6297 spec->num_pwrs = 0; 6298 6299 spec->init = stac9205_core_init; 6300 spec->aloopback_ctl = stac9205_loopback; 6301 6302 spec->num_caps = STAC9205_NUM_CAPS; 6303 spec->capvols = stac9205_capvols; 6304 spec->capsws = stac9205_capsws; 6305 6306 spec->aloopback_mask = 0x40; 6307 spec->aloopback_shift = 0; 6308 /* Turn on/off EAPD per HP plugging */ 6309 if (spec->board_config != STAC_9205_EAPD) 6310 spec->eapd_switch = 1; 6311 spec->multiout.dac_nids = spec->dac_nids; 6312 6313 switch (spec->board_config){ 6314 case STAC_9205_DELL_M43: 6315 /* Enable SPDIF in/out */ 6316 snd_hda_codec_set_pincfg(codec, 0x1f, 0x01441030); 6317 snd_hda_codec_set_pincfg(codec, 0x20, 0x1c410030); 6318 6319 /* Enable unsol response for GPIO4/Dock HP connection */ 6320 err = stac_add_event(codec, codec->afg, STAC_VREF_EVENT, 0x01); 6321 if (err < 0) 6322 return err; 6323 snd_hda_codec_write_cache(codec, codec->afg, 0, 6324 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10); 6325 snd_hda_jack_detect_enable(codec, codec->afg, 0); 6326 6327 spec->gpio_dir = 0x0b; 6328 spec->eapd_mask = 0x01; 6329 spec->gpio_mask = 0x1b; 6330 spec->gpio_mute = 0x10; 6331 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute, 6332 * GPIO3 Low = DRM 6333 */ 6334 spec->gpio_data = 0x01; 6335 break; 6336 case STAC_9205_REF: 6337 /* SPDIF-In enabled */ 6338 break; 6339 default: 6340 /* GPIO0 High = EAPD */ 6341 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 6342 spec->gpio_data = 0x01; 6343 break; 6344 } 6345 6346 err = stac92xx_parse_auto_config(codec); 6347 if (!err) { 6348 if (spec->board_config < 0) { 6349 printk(KERN_WARNING "hda_codec: No auto-config is " 6350 "available, default to model=ref\n"); 6351 spec->board_config = STAC_9205_REF; 6352 goto again; 6353 } 6354 err = -EINVAL; 6355 } 6356 if (err < 0) { 6357 stac92xx_free(codec); 6358 return err; 6359 } 6360 6361 codec->patch_ops = stac92xx_patch_ops; 6362 6363 codec->proc_widget_hook = stac9205_proc_hook; 6364 6365 return 0; 6366 } 6367 6368 /* 6369 * STAC9872 hack 6370 */ 6371 6372 static const struct hda_verb stac9872_core_init[] = { 6373 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */ 6374 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */ 6375 {} 6376 }; 6377 6378 static const hda_nid_t stac9872_pin_nids[] = { 6379 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 6380 0x11, 0x13, 0x14, 6381 }; 6382 6383 static const hda_nid_t stac9872_adc_nids[] = { 6384 0x8 /*,0x6*/ 6385 }; 6386 6387 static const hda_nid_t stac9872_mux_nids[] = { 6388 0x15 6389 }; 6390 6391 static const unsigned long stac9872_capvols[] = { 6392 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT), 6393 }; 6394 #define stac9872_capsws stac9872_capvols 6395 6396 static const unsigned int stac9872_vaio_pin_configs[9] = { 6397 0x03211020, 0x411111f0, 0x411111f0, 0x03a15030, 6398 0x411111f0, 0x90170110, 0x411111f0, 0x411111f0, 6399 0x90a7013e 6400 }; 6401 6402 static const char * const stac9872_models[STAC_9872_MODELS] = { 6403 [STAC_9872_AUTO] = "auto", 6404 [STAC_9872_VAIO] = "vaio", 6405 }; 6406 6407 static const unsigned int *stac9872_brd_tbl[STAC_9872_MODELS] = { 6408 [STAC_9872_VAIO] = stac9872_vaio_pin_configs, 6409 }; 6410 6411 static const struct snd_pci_quirk stac9872_cfg_tbl[] = { 6412 SND_PCI_QUIRK_MASK(0x104d, 0xfff0, 0x81e0, 6413 "Sony VAIO F/S", STAC_9872_VAIO), 6414 {} /* terminator */ 6415 }; 6416 6417 static int patch_stac9872(struct hda_codec *codec) 6418 { 6419 struct sigmatel_spec *spec; 6420 int err; 6421 6422 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 6423 if (spec == NULL) 6424 return -ENOMEM; 6425 codec->no_trigger_sense = 1; 6426 codec->spec = spec; 6427 spec->linear_tone_beep = 1; 6428 spec->num_pins = ARRAY_SIZE(stac9872_pin_nids); 6429 spec->pin_nids = stac9872_pin_nids; 6430 6431 spec->board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS, 6432 stac9872_models, 6433 stac9872_cfg_tbl); 6434 if (spec->board_config < 0) 6435 snd_printdd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n", 6436 codec->chip_name); 6437 else 6438 stac92xx_set_config_regs(codec, 6439 stac9872_brd_tbl[spec->board_config]); 6440 6441 spec->multiout.dac_nids = spec->dac_nids; 6442 spec->num_adcs = ARRAY_SIZE(stac9872_adc_nids); 6443 spec->adc_nids = stac9872_adc_nids; 6444 spec->num_muxes = ARRAY_SIZE(stac9872_mux_nids); 6445 spec->mux_nids = stac9872_mux_nids; 6446 spec->init = stac9872_core_init; 6447 spec->num_caps = 1; 6448 spec->capvols = stac9872_capvols; 6449 spec->capsws = stac9872_capsws; 6450 6451 err = stac92xx_parse_auto_config(codec); 6452 if (err < 0) { 6453 stac92xx_free(codec); 6454 return -EINVAL; 6455 } 6456 spec->input_mux = &spec->private_imux; 6457 codec->patch_ops = stac92xx_patch_ops; 6458 return 0; 6459 } 6460 6461 6462 /* 6463 * patch entries 6464 */ 6465 static const struct hda_codec_preset snd_hda_preset_sigmatel[] = { 6466 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 }, 6467 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x }, 6468 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x }, 6469 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x }, 6470 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x }, 6471 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x }, 6472 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x }, 6473 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x }, 6474 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x }, 6475 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x }, 6476 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x }, 6477 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x }, 6478 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x }, 6479 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x }, 6480 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x }, 6481 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x }, 6482 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x }, 6483 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x }, 6484 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x }, 6485 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x }, 6486 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x }, 6487 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x }, 6488 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x }, 6489 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x }, 6490 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x }, 6491 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x }, 6492 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x }, 6493 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x }, 6494 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x }, 6495 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x }, 6496 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x }, 6497 /* The following does not take into account .id=0x83847661 when subsys = 6498 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are 6499 * currently not fully supported. 6500 */ 6501 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 }, 6502 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 }, 6503 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 }, 6504 { .id = 0x83847698, .name = "STAC9205", .patch = patch_stac9205 }, 6505 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 }, 6506 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 }, 6507 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 }, 6508 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 }, 6509 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 }, 6510 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 }, 6511 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 }, 6512 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 }, 6513 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx}, 6514 { .id = 0x111d7604, .name = "92HD83C1X5", .patch = patch_stac92hd83xxx}, 6515 { .id = 0x111d76d4, .name = "92HD83C1C5", .patch = patch_stac92hd83xxx}, 6516 { .id = 0x111d7605, .name = "92HD81B1X5", .patch = patch_stac92hd83xxx}, 6517 { .id = 0x111d76d5, .name = "92HD81B1C5", .patch = patch_stac92hd83xxx}, 6518 { .id = 0x111d76d1, .name = "92HD87B1/3", .patch = patch_stac92hd83xxx}, 6519 { .id = 0x111d76d9, .name = "92HD87B2/4", .patch = patch_stac92hd83xxx}, 6520 { .id = 0x111d7666, .name = "92HD88B3", .patch = patch_stac92hd83xxx}, 6521 { .id = 0x111d7667, .name = "92HD88B1", .patch = patch_stac92hd83xxx}, 6522 { .id = 0x111d7668, .name = "92HD88B2", .patch = patch_stac92hd83xxx}, 6523 { .id = 0x111d7669, .name = "92HD88B4", .patch = patch_stac92hd83xxx}, 6524 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx}, 6525 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx }, 6526 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx }, 6527 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx }, 6528 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6529 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 6530 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6531 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 6532 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6533 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 6534 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6535 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 6536 { .id = 0x111d76c0, .name = "92HD89C3", .patch = patch_stac92hd73xx }, 6537 { .id = 0x111d76c1, .name = "92HD89C2", .patch = patch_stac92hd73xx }, 6538 { .id = 0x111d76c2, .name = "92HD89C1", .patch = patch_stac92hd73xx }, 6539 { .id = 0x111d76c3, .name = "92HD89B3", .patch = patch_stac92hd73xx }, 6540 { .id = 0x111d76c4, .name = "92HD89B2", .patch = patch_stac92hd73xx }, 6541 { .id = 0x111d76c5, .name = "92HD89B1", .patch = patch_stac92hd73xx }, 6542 { .id = 0x111d76c6, .name = "92HD89E3", .patch = patch_stac92hd73xx }, 6543 { .id = 0x111d76c7, .name = "92HD89E2", .patch = patch_stac92hd73xx }, 6544 { .id = 0x111d76c8, .name = "92HD89E1", .patch = patch_stac92hd73xx }, 6545 { .id = 0x111d76c9, .name = "92HD89D3", .patch = patch_stac92hd73xx }, 6546 { .id = 0x111d76ca, .name = "92HD89D2", .patch = patch_stac92hd73xx }, 6547 { .id = 0x111d76cb, .name = "92HD89D1", .patch = patch_stac92hd73xx }, 6548 { .id = 0x111d76cc, .name = "92HD89F3", .patch = patch_stac92hd73xx }, 6549 { .id = 0x111d76cd, .name = "92HD89F2", .patch = patch_stac92hd73xx }, 6550 { .id = 0x111d76ce, .name = "92HD89F1", .patch = patch_stac92hd73xx }, 6551 { .id = 0x111d76df, .name = "92HD93BXX", .patch = patch_stac92hd83xxx}, 6552 { .id = 0x111d76e0, .name = "92HD91BXX", .patch = patch_stac92hd83xxx}, 6553 { .id = 0x111d76e3, .name = "92HD98BXX", .patch = patch_stac92hd83xxx}, 6554 { .id = 0x111d76e5, .name = "92HD99BXX", .patch = patch_stac92hd83xxx}, 6555 { .id = 0x111d76e7, .name = "92HD90BXX", .patch = patch_stac92hd83xxx}, 6556 { .id = 0x111d76e8, .name = "92HD66B1X5", .patch = patch_stac92hd83xxx}, 6557 { .id = 0x111d76e9, .name = "92HD66B2X5", .patch = patch_stac92hd83xxx}, 6558 { .id = 0x111d76ea, .name = "92HD66B3X5", .patch = patch_stac92hd83xxx}, 6559 { .id = 0x111d76eb, .name = "92HD66C1X5", .patch = patch_stac92hd83xxx}, 6560 { .id = 0x111d76ec, .name = "92HD66C2X5", .patch = patch_stac92hd83xxx}, 6561 { .id = 0x111d76ed, .name = "92HD66C3X5", .patch = patch_stac92hd83xxx}, 6562 { .id = 0x111d76ee, .name = "92HD66B1X3", .patch = patch_stac92hd83xxx}, 6563 { .id = 0x111d76ef, .name = "92HD66B2X3", .patch = patch_stac92hd83xxx}, 6564 { .id = 0x111d76f0, .name = "92HD66B3X3", .patch = patch_stac92hd83xxx}, 6565 { .id = 0x111d76f1, .name = "92HD66C1X3", .patch = patch_stac92hd83xxx}, 6566 { .id = 0x111d76f2, .name = "92HD66C2X3", .patch = patch_stac92hd83xxx}, 6567 { .id = 0x111d76f3, .name = "92HD66C3/65", .patch = patch_stac92hd83xxx}, 6568 {} /* terminator */ 6569 }; 6570 6571 MODULE_ALIAS("snd-hda-codec-id:8384*"); 6572 MODULE_ALIAS("snd-hda-codec-id:111d*"); 6573 6574 MODULE_LICENSE("GPL"); 6575 MODULE_DESCRIPTION("IDT/Sigmatel HD-audio codec"); 6576 6577 static struct hda_codec_preset_list sigmatel_list = { 6578 .preset = snd_hda_preset_sigmatel, 6579 .owner = THIS_MODULE, 6580 }; 6581 6582 static int __init patch_sigmatel_init(void) 6583 { 6584 return snd_hda_add_codec_preset(&sigmatel_list); 6585 } 6586 6587 static void __exit patch_sigmatel_exit(void) 6588 { 6589 snd_hda_delete_codec_preset(&sigmatel_list); 6590 } 6591 6592 module_init(patch_sigmatel_init) 6593 module_exit(patch_sigmatel_exit) 6594