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