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