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 <sound/core.h> 32 #include <sound/asoundef.h> 33 #include "hda_codec.h" 34 #include "hda_local.h" 35 #include "hda_patch.h" 36 37 #define NUM_CONTROL_ALLOC 32 38 #define STAC_PWR_EVENT 0x20 39 #define STAC_HP_EVENT 0x30 40 41 enum { 42 STAC_REF, 43 STAC_9200_OQO, 44 STAC_9200_DELL_D21, 45 STAC_9200_DELL_D22, 46 STAC_9200_DELL_D23, 47 STAC_9200_DELL_M21, 48 STAC_9200_DELL_M22, 49 STAC_9200_DELL_M23, 50 STAC_9200_DELL_M24, 51 STAC_9200_DELL_M25, 52 STAC_9200_DELL_M26, 53 STAC_9200_DELL_M27, 54 STAC_9200_GATEWAY, 55 STAC_9200_PANASONIC, 56 STAC_9200_MODELS 57 }; 58 59 enum { 60 STAC_9205_REF, 61 STAC_9205_DELL_M42, 62 STAC_9205_DELL_M43, 63 STAC_9205_DELL_M44, 64 STAC_9205_MODELS 65 }; 66 67 enum { 68 STAC_92HD73XX_REF, 69 STAC_DELL_M6, 70 STAC_92HD73XX_MODELS 71 }; 72 73 enum { 74 STAC_92HD71BXX_REF, 75 STAC_DELL_M4_1, 76 STAC_DELL_M4_2, 77 STAC_92HD71BXX_MODELS 78 }; 79 80 enum { 81 STAC_925x_REF, 82 STAC_M2_2, 83 STAC_MA6, 84 STAC_PA6, 85 STAC_925x_MODELS 86 }; 87 88 enum { 89 STAC_D945_REF, 90 STAC_D945GTP3, 91 STAC_D945GTP5, 92 STAC_INTEL_MAC_V1, 93 STAC_INTEL_MAC_V2, 94 STAC_INTEL_MAC_V3, 95 STAC_INTEL_MAC_V4, 96 STAC_INTEL_MAC_V5, 97 STAC_INTEL_MAC_AUTO, /* This model is selected if no module parameter 98 * is given, one of the above models will be 99 * chosen according to the subsystem id. */ 100 /* for backward compatibility */ 101 STAC_MACMINI, 102 STAC_MACBOOK, 103 STAC_MACBOOK_PRO_V1, 104 STAC_MACBOOK_PRO_V2, 105 STAC_IMAC_INTEL, 106 STAC_IMAC_INTEL_20, 107 STAC_922X_DELL_D81, 108 STAC_922X_DELL_D82, 109 STAC_922X_DELL_M81, 110 STAC_922X_DELL_M82, 111 STAC_922X_MODELS 112 }; 113 114 enum { 115 STAC_D965_REF, 116 STAC_D965_3ST, 117 STAC_D965_5ST, 118 STAC_DELL_3ST, 119 STAC_DELL_BIOS, 120 STAC_927X_MODELS 121 }; 122 123 struct sigmatel_spec { 124 struct snd_kcontrol_new *mixers[4]; 125 unsigned int num_mixers; 126 127 int board_config; 128 unsigned int surr_switch: 1; 129 unsigned int line_switch: 1; 130 unsigned int mic_switch: 1; 131 unsigned int alt_switch: 1; 132 unsigned int hp_detect: 1; 133 134 /* gpio lines */ 135 unsigned int eapd_mask; 136 unsigned int gpio_mask; 137 unsigned int gpio_dir; 138 unsigned int gpio_data; 139 unsigned int gpio_mute; 140 141 /* analog loopback */ 142 unsigned char aloopback_mask; 143 unsigned char aloopback_shift; 144 145 /* power management */ 146 unsigned int num_pwrs; 147 hda_nid_t *pwr_nids; 148 hda_nid_t *dac_list; 149 150 /* playback */ 151 struct hda_input_mux *mono_mux; 152 unsigned int cur_mmux; 153 struct hda_multi_out multiout; 154 hda_nid_t dac_nids[5]; 155 156 /* capture */ 157 hda_nid_t *adc_nids; 158 unsigned int num_adcs; 159 hda_nid_t *mux_nids; 160 unsigned int num_muxes; 161 hda_nid_t *dmic_nids; 162 unsigned int num_dmics; 163 hda_nid_t *dmux_nids; 164 unsigned int num_dmuxes; 165 hda_nid_t dig_in_nid; 166 hda_nid_t mono_nid; 167 168 /* pin widgets */ 169 hda_nid_t *pin_nids; 170 unsigned int num_pins; 171 unsigned int *pin_configs; 172 unsigned int *bios_pin_configs; 173 174 /* codec specific stuff */ 175 struct hda_verb *init; 176 struct snd_kcontrol_new *mixer; 177 178 /* capture source */ 179 struct hda_input_mux *dinput_mux; 180 unsigned int cur_dmux[2]; 181 struct hda_input_mux *input_mux; 182 unsigned int cur_mux[3]; 183 184 /* i/o switches */ 185 unsigned int io_switch[2]; 186 unsigned int clfe_swap; 187 unsigned int hp_switch; 188 unsigned int aloopback; 189 190 struct hda_pcm pcm_rec[2]; /* PCM information */ 191 192 /* dynamic controls and input_mux */ 193 struct auto_pin_cfg autocfg; 194 unsigned int num_kctl_alloc, num_kctl_used; 195 struct snd_kcontrol_new *kctl_alloc; 196 struct hda_input_mux private_dimux; 197 struct hda_input_mux private_imux; 198 struct hda_input_mux private_mono_mux; 199 }; 200 201 static hda_nid_t stac9200_adc_nids[1] = { 202 0x03, 203 }; 204 205 static hda_nid_t stac9200_mux_nids[1] = { 206 0x0c, 207 }; 208 209 static hda_nid_t stac9200_dac_nids[1] = { 210 0x02, 211 }; 212 213 static hda_nid_t stac92hd73xx_pwr_nids[8] = { 214 0x0a, 0x0b, 0x0c, 0xd, 0x0e, 215 0x0f, 0x10, 0x11 216 }; 217 218 static hda_nid_t stac92hd73xx_adc_nids[2] = { 219 0x1a, 0x1b 220 }; 221 222 #define STAC92HD73XX_NUM_DMICS 2 223 static hda_nid_t stac92hd73xx_dmic_nids[STAC92HD73XX_NUM_DMICS + 1] = { 224 0x13, 0x14, 0 225 }; 226 227 #define STAC92HD73_DAC_COUNT 5 228 static hda_nid_t stac92hd73xx_dac_nids[STAC92HD73_DAC_COUNT] = { 229 0x15, 0x16, 0x17, 0x18, 0x19, 230 }; 231 232 static hda_nid_t stac92hd73xx_mux_nids[4] = { 233 0x28, 0x29, 0x2a, 0x2b, 234 }; 235 236 static hda_nid_t stac92hd73xx_dmux_nids[2] = { 237 0x20, 0x21, 238 }; 239 240 static hda_nid_t stac92hd71bxx_pwr_nids[3] = { 241 0x0a, 0x0d, 0x0f 242 }; 243 244 static hda_nid_t stac92hd71bxx_adc_nids[2] = { 245 0x12, 0x13, 246 }; 247 248 static hda_nid_t stac92hd71bxx_mux_nids[2] = { 249 0x1a, 0x1b 250 }; 251 252 static hda_nid_t stac92hd71bxx_dmux_nids[1] = { 253 0x1c, 254 }; 255 256 static hda_nid_t stac92hd71bxx_dac_nids[1] = { 257 0x10, /*0x11, */ 258 }; 259 260 #define STAC92HD71BXX_NUM_DMICS 2 261 static hda_nid_t stac92hd71bxx_dmic_nids[STAC92HD71BXX_NUM_DMICS + 1] = { 262 0x18, 0x19, 0 263 }; 264 265 static hda_nid_t stac925x_adc_nids[1] = { 266 0x03, 267 }; 268 269 static hda_nid_t stac925x_mux_nids[1] = { 270 0x0f, 271 }; 272 273 static hda_nid_t stac925x_dac_nids[1] = { 274 0x02, 275 }; 276 277 #define STAC925X_NUM_DMICS 1 278 static hda_nid_t stac925x_dmic_nids[STAC925X_NUM_DMICS + 1] = { 279 0x15, 0 280 }; 281 282 static hda_nid_t stac925x_dmux_nids[1] = { 283 0x14, 284 }; 285 286 static hda_nid_t stac922x_adc_nids[2] = { 287 0x06, 0x07, 288 }; 289 290 static hda_nid_t stac922x_mux_nids[2] = { 291 0x12, 0x13, 292 }; 293 294 static hda_nid_t stac927x_adc_nids[3] = { 295 0x07, 0x08, 0x09 296 }; 297 298 static hda_nid_t stac927x_mux_nids[3] = { 299 0x15, 0x16, 0x17 300 }; 301 302 static hda_nid_t stac927x_dac_nids[6] = { 303 0x02, 0x03, 0x04, 0x05, 0x06, 0 304 }; 305 306 static hda_nid_t stac927x_dmux_nids[1] = { 307 0x1b, 308 }; 309 310 #define STAC927X_NUM_DMICS 2 311 static hda_nid_t stac927x_dmic_nids[STAC927X_NUM_DMICS + 1] = { 312 0x13, 0x14, 0 313 }; 314 315 static hda_nid_t stac9205_adc_nids[2] = { 316 0x12, 0x13 317 }; 318 319 static hda_nid_t stac9205_mux_nids[2] = { 320 0x19, 0x1a 321 }; 322 323 static hda_nid_t stac9205_dmux_nids[1] = { 324 0x1d, 325 }; 326 327 #define STAC9205_NUM_DMICS 2 328 static hda_nid_t stac9205_dmic_nids[STAC9205_NUM_DMICS + 1] = { 329 0x17, 0x18, 0 330 }; 331 332 static hda_nid_t stac9200_pin_nids[8] = { 333 0x08, 0x09, 0x0d, 0x0e, 334 0x0f, 0x10, 0x11, 0x12, 335 }; 336 337 static hda_nid_t stac925x_pin_nids[8] = { 338 0x07, 0x08, 0x0a, 0x0b, 339 0x0c, 0x0d, 0x10, 0x11, 340 }; 341 342 static hda_nid_t stac922x_pin_nids[10] = { 343 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 344 0x0f, 0x10, 0x11, 0x15, 0x1b, 345 }; 346 347 static hda_nid_t stac92hd73xx_pin_nids[13] = { 348 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 349 0x0f, 0x10, 0x11, 0x12, 0x13, 350 0x14, 0x1e, 0x22 351 }; 352 353 static hda_nid_t stac92hd71bxx_pin_nids[10] = { 354 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 355 0x0f, 0x14, 0x18, 0x19, 0x1e, 356 }; 357 358 static hda_nid_t stac927x_pin_nids[14] = { 359 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 360 0x0f, 0x10, 0x11, 0x12, 0x13, 361 0x14, 0x21, 0x22, 0x23, 362 }; 363 364 static hda_nid_t stac9205_pin_nids[12] = { 365 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 366 0x0f, 0x14, 0x16, 0x17, 0x18, 367 0x21, 0x22, 368 }; 369 370 static int stac92xx_dmux_enum_info(struct snd_kcontrol *kcontrol, 371 struct snd_ctl_elem_info *uinfo) 372 { 373 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 374 struct sigmatel_spec *spec = codec->spec; 375 return snd_hda_input_mux_info(spec->dinput_mux, uinfo); 376 } 377 378 static int stac92xx_dmux_enum_get(struct snd_kcontrol *kcontrol, 379 struct snd_ctl_elem_value *ucontrol) 380 { 381 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 382 struct sigmatel_spec *spec = codec->spec; 383 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 384 385 ucontrol->value.enumerated.item[0] = spec->cur_dmux[dmux_idx]; 386 return 0; 387 } 388 389 static int stac92xx_dmux_enum_put(struct snd_kcontrol *kcontrol, 390 struct snd_ctl_elem_value *ucontrol) 391 { 392 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 393 struct sigmatel_spec *spec = codec->spec; 394 unsigned int dmux_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 395 396 return snd_hda_input_mux_put(codec, spec->dinput_mux, ucontrol, 397 spec->dmux_nids[dmux_idx], &spec->cur_dmux[dmux_idx]); 398 } 399 400 static int stac92xx_mux_enum_info(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_info *uinfo) 401 { 402 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 403 struct sigmatel_spec *spec = codec->spec; 404 return snd_hda_input_mux_info(spec->input_mux, uinfo); 405 } 406 407 static int stac92xx_mux_enum_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 408 { 409 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 410 struct sigmatel_spec *spec = codec->spec; 411 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 412 413 ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx]; 414 return 0; 415 } 416 417 static int stac92xx_mux_enum_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 418 { 419 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 420 struct sigmatel_spec *spec = codec->spec; 421 unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 422 423 return snd_hda_input_mux_put(codec, spec->input_mux, ucontrol, 424 spec->mux_nids[adc_idx], &spec->cur_mux[adc_idx]); 425 } 426 427 static int stac92xx_mono_mux_enum_info(struct snd_kcontrol *kcontrol, 428 struct snd_ctl_elem_info *uinfo) 429 { 430 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 431 struct sigmatel_spec *spec = codec->spec; 432 return snd_hda_input_mux_info(spec->mono_mux, uinfo); 433 } 434 435 static int stac92xx_mono_mux_enum_get(struct snd_kcontrol *kcontrol, 436 struct snd_ctl_elem_value *ucontrol) 437 { 438 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 439 struct sigmatel_spec *spec = codec->spec; 440 441 ucontrol->value.enumerated.item[0] = spec->cur_mmux; 442 return 0; 443 } 444 445 static int stac92xx_mono_mux_enum_put(struct snd_kcontrol *kcontrol, 446 struct snd_ctl_elem_value *ucontrol) 447 { 448 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 449 struct sigmatel_spec *spec = codec->spec; 450 451 return snd_hda_input_mux_put(codec, spec->mono_mux, ucontrol, 452 spec->mono_nid, &spec->cur_mmux); 453 } 454 455 #define stac92xx_aloopback_info snd_ctl_boolean_mono_info 456 457 static int stac92xx_aloopback_get(struct snd_kcontrol *kcontrol, 458 struct snd_ctl_elem_value *ucontrol) 459 { 460 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 461 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 462 struct sigmatel_spec *spec = codec->spec; 463 464 ucontrol->value.integer.value[0] = !!(spec->aloopback & 465 (spec->aloopback_mask << idx)); 466 return 0; 467 } 468 469 static int stac92xx_aloopback_put(struct snd_kcontrol *kcontrol, 470 struct snd_ctl_elem_value *ucontrol) 471 { 472 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 473 struct sigmatel_spec *spec = codec->spec; 474 unsigned int idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id); 475 unsigned int dac_mode; 476 unsigned int val, idx_val; 477 478 idx_val = spec->aloopback_mask << idx; 479 if (ucontrol->value.integer.value[0]) 480 val = spec->aloopback | idx_val; 481 else 482 val = spec->aloopback & ~idx_val; 483 if (spec->aloopback == val) 484 return 0; 485 486 spec->aloopback = val; 487 488 /* Only return the bits defined by the shift value of the 489 * first two bytes of the mask 490 */ 491 dac_mode = snd_hda_codec_read(codec, codec->afg, 0, 492 kcontrol->private_value & 0xFFFF, 0x0); 493 dac_mode >>= spec->aloopback_shift; 494 495 if (spec->aloopback & idx_val) { 496 snd_hda_power_up(codec); 497 dac_mode |= idx_val; 498 } else { 499 snd_hda_power_down(codec); 500 dac_mode &= ~idx_val; 501 } 502 503 snd_hda_codec_write_cache(codec, codec->afg, 0, 504 kcontrol->private_value >> 16, dac_mode); 505 506 return 1; 507 } 508 509 static struct hda_verb stac9200_core_init[] = { 510 /* set dac0mux for dac converter */ 511 { 0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 512 {} 513 }; 514 515 static struct hda_verb stac9200_eapd_init[] = { 516 /* set dac0mux for dac converter */ 517 {0x07, AC_VERB_SET_CONNECT_SEL, 0x00}, 518 {0x08, AC_VERB_SET_EAPD_BTLENABLE, 0x02}, 519 {} 520 }; 521 522 static struct hda_verb stac92hd73xx_6ch_core_init[] = { 523 /* set master volume and direct control */ 524 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 525 /* setup audio connections */ 526 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00}, 527 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01}, 528 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02}, 529 /* setup adcs to point to mixer */ 530 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b}, 531 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b}, 532 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 533 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 534 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 535 /* setup import muxs */ 536 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01}, 537 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01}, 538 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01}, 539 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00}, 540 {} 541 }; 542 543 static struct hda_verb dell_eq_core_init[] = { 544 /* set master volume to max value without distortion 545 * and direct control */ 546 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xec}, 547 /* setup audio connections */ 548 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 549 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01}, 550 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02}, 551 /* setup adcs to point to mixer */ 552 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b}, 553 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b}, 554 /* setup import muxs */ 555 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01}, 556 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01}, 557 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01}, 558 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00}, 559 {} 560 }; 561 562 static struct hda_verb dell_m6_core_init[] = { 563 /* set master volume and direct control */ 564 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 565 /* setup audio connections */ 566 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00}, 567 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01}, 568 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x02}, 569 /* setup adcs to point to mixer */ 570 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b}, 571 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b}, 572 /* setup import muxs */ 573 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01}, 574 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01}, 575 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01}, 576 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x00}, 577 {} 578 }; 579 580 static struct hda_verb stac92hd73xx_8ch_core_init[] = { 581 /* set master volume and direct control */ 582 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 583 /* setup audio connections */ 584 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00}, 585 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01}, 586 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02}, 587 /* connect hp ports to dac3 */ 588 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x03}, 589 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x03}, 590 /* setup adcs to point to mixer */ 591 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b}, 592 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b}, 593 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 594 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 595 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 596 /* setup import muxs */ 597 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01}, 598 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01}, 599 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01}, 600 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03}, 601 {} 602 }; 603 604 static struct hda_verb stac92hd73xx_10ch_core_init[] = { 605 /* set master volume and direct control */ 606 { 0x1f, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 607 /* setup audio connections */ 608 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 }, 609 { 0x10, AC_VERB_SET_CONNECT_SEL, 0x01 }, 610 { 0x11, AC_VERB_SET_CONNECT_SEL, 0x02 }, 611 /* dac3 is connected to import3 mux */ 612 { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0xb07f}, 613 /* connect hp ports to dac4 */ 614 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x04}, 615 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x04}, 616 /* setup adcs to point to mixer */ 617 { 0x20, AC_VERB_SET_CONNECT_SEL, 0x0b}, 618 { 0x21, AC_VERB_SET_CONNECT_SEL, 0x0b}, 619 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 620 { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 621 { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, 622 /* setup import muxs */ 623 { 0x28, AC_VERB_SET_CONNECT_SEL, 0x01}, 624 { 0x29, AC_VERB_SET_CONNECT_SEL, 0x01}, 625 { 0x2a, AC_VERB_SET_CONNECT_SEL, 0x01}, 626 { 0x2b, AC_VERB_SET_CONNECT_SEL, 0x03}, 627 {} 628 }; 629 630 static struct hda_verb stac92hd71bxx_core_init[] = { 631 /* set master volume and direct control */ 632 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 633 /* connect headphone jack to dac1 */ 634 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01}, 635 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */ 636 /* unmute right and left channels for nodes 0x0a, 0xd, 0x0f */ 637 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 638 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 639 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 640 }; 641 642 #define HD_DISABLE_PORTF 3 643 static struct hda_verb stac92hd71bxx_analog_core_init[] = { 644 /* start of config #1 */ 645 646 /* connect port 0f to audio mixer */ 647 { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x2}, 648 { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT}, /* Speaker */ 649 /* unmute right and left channels for node 0x0f */ 650 { 0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 651 /* start of config #2 */ 652 653 /* set master volume and direct control */ 654 { 0x28, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 655 /* connect headphone jack to dac1 */ 656 { 0x0a, AC_VERB_SET_CONNECT_SEL, 0x01}, 657 /* connect port 0d to audio mixer */ 658 { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x2}, 659 /* unmute dac0 input in audio mixer */ 660 { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f}, 661 /* unmute right and left channels for nodes 0x0a, 0xd */ 662 { 0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 663 { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, 664 {} 665 }; 666 667 static struct hda_verb stac925x_core_init[] = { 668 /* set dac0mux for dac converter */ 669 { 0x06, AC_VERB_SET_CONNECT_SEL, 0x00}, 670 {} 671 }; 672 673 static struct hda_verb stac922x_core_init[] = { 674 /* set master volume and direct control */ 675 { 0x16, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 676 {} 677 }; 678 679 static struct hda_verb d965_core_init[] = { 680 /* set master volume and direct control */ 681 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 682 /* unmute node 0x1b */ 683 { 0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000}, 684 /* select node 0x03 as DAC */ 685 { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x01}, 686 {} 687 }; 688 689 static struct hda_verb stac927x_core_init[] = { 690 /* set master volume and direct control */ 691 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 692 {} 693 }; 694 695 static struct hda_verb stac9205_core_init[] = { 696 /* set master volume and direct control */ 697 { 0x24, AC_VERB_SET_VOLUME_KNOB_CONTROL, 0xff}, 698 {} 699 }; 700 701 #define STAC_MONO_MUX \ 702 { \ 703 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 704 .name = "Mono Mux", \ 705 .count = 1, \ 706 .info = stac92xx_mono_mux_enum_info, \ 707 .get = stac92xx_mono_mux_enum_get, \ 708 .put = stac92xx_mono_mux_enum_put, \ 709 } 710 711 #define STAC_INPUT_SOURCE(cnt) \ 712 { \ 713 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 714 .name = "Input Source", \ 715 .count = cnt, \ 716 .info = stac92xx_mux_enum_info, \ 717 .get = stac92xx_mux_enum_get, \ 718 .put = stac92xx_mux_enum_put, \ 719 } 720 721 #define STAC_ANALOG_LOOPBACK(verb_read, verb_write, cnt) \ 722 { \ 723 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 724 .name = "Analog Loopback", \ 725 .count = cnt, \ 726 .info = stac92xx_aloopback_info, \ 727 .get = stac92xx_aloopback_get, \ 728 .put = stac92xx_aloopback_put, \ 729 .private_value = verb_read | (verb_write << 16), \ 730 } 731 732 static struct snd_kcontrol_new stac9200_mixer[] = { 733 HDA_CODEC_VOLUME("Master Playback Volume", 0xb, 0, HDA_OUTPUT), 734 HDA_CODEC_MUTE("Master Playback Switch", 0xb, 0, HDA_OUTPUT), 735 STAC_INPUT_SOURCE(1), 736 HDA_CODEC_VOLUME("Capture Volume", 0x0a, 0, HDA_OUTPUT), 737 HDA_CODEC_MUTE("Capture Switch", 0x0a, 0, HDA_OUTPUT), 738 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0c, 0, HDA_OUTPUT), 739 { } /* end */ 740 }; 741 742 static struct snd_kcontrol_new stac92hd73xx_6ch_mixer[] = { 743 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 3), 744 745 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT), 746 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT), 747 748 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT), 749 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT), 750 751 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT), 752 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT), 753 754 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT), 755 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT), 756 757 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT), 758 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT), 759 760 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT), 761 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT), 762 763 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT), 764 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT), 765 { } /* end */ 766 }; 767 768 static struct snd_kcontrol_new stac92hd73xx_8ch_mixer[] = { 769 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 4), 770 771 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT), 772 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT), 773 774 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT), 775 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT), 776 777 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT), 778 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT), 779 780 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT), 781 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT), 782 783 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT), 784 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT), 785 786 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT), 787 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT), 788 789 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT), 790 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT), 791 { } /* end */ 792 }; 793 794 static struct snd_kcontrol_new stac92hd73xx_10ch_mixer[] = { 795 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A1, 5), 796 797 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x20, 0x0, HDA_OUTPUT), 798 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x20, 0x0, HDA_OUTPUT), 799 800 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x21, 0x0, HDA_OUTPUT), 801 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x21, 0x0, HDA_OUTPUT), 802 803 HDA_CODEC_VOLUME("Front Mic Mixer Capture Volume", 0x1d, 0, HDA_INPUT), 804 HDA_CODEC_MUTE("Front Mic Mixer Capture Switch", 0x1d, 0, HDA_INPUT), 805 806 HDA_CODEC_VOLUME("Mic Mixer Capture Volume", 0x1d, 0x1, HDA_INPUT), 807 HDA_CODEC_MUTE("Mic Mixer Capture Switch", 0x1d, 0x1, HDA_INPUT), 808 809 HDA_CODEC_VOLUME("Line In Mixer Capture Volume", 0x1d, 0x2, HDA_INPUT), 810 HDA_CODEC_MUTE("Line In Mixer Capture Switch", 0x1d, 0x2, HDA_INPUT), 811 812 HDA_CODEC_VOLUME("DAC Mixer Capture Volume", 0x1d, 0x3, HDA_INPUT), 813 HDA_CODEC_MUTE("DAC Mixer Capture Switch", 0x1d, 0x3, HDA_INPUT), 814 815 HDA_CODEC_VOLUME("CD Mixer Capture Volume", 0x1d, 0x4, HDA_INPUT), 816 HDA_CODEC_MUTE("CD Mixer Capture Switch", 0x1d, 0x4, HDA_INPUT), 817 { } /* end */ 818 }; 819 820 static struct snd_kcontrol_new stac92hd71bxx_analog_mixer[] = { 821 STAC_INPUT_SOURCE(2), 822 823 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT), 824 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT), 825 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT), 826 827 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT), 828 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT), 829 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT), 830 831 HDA_CODEC_VOLUME("PC Beep Volume", 0x17, 0x2, HDA_INPUT), 832 HDA_CODEC_MUTE("PC Beep Switch", 0x17, 0x2, HDA_INPUT), 833 834 HDA_CODEC_MUTE("Analog Loopback 1", 0x17, 0x3, HDA_INPUT), 835 HDA_CODEC_MUTE("Analog Loopback 2", 0x17, 0x4, HDA_INPUT), 836 { } /* end */ 837 }; 838 839 static struct snd_kcontrol_new stac92hd71bxx_mixer[] = { 840 STAC_INPUT_SOURCE(2), 841 STAC_ANALOG_LOOPBACK(0xFA0, 0x7A0, 2), 842 843 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1c, 0x0, HDA_OUTPUT), 844 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1c, 0x0, HDA_OUTPUT), 845 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x0, 0x1a, 0x0, HDA_OUTPUT), 846 847 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1d, 0x0, HDA_OUTPUT), 848 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1d, 0x0, HDA_OUTPUT), 849 HDA_CODEC_VOLUME_IDX("Capture Mux Volume", 0x1, 0x1b, 0x0, HDA_OUTPUT), 850 { } /* end */ 851 }; 852 853 static struct snd_kcontrol_new stac925x_mixer[] = { 854 STAC_INPUT_SOURCE(1), 855 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_OUTPUT), 856 HDA_CODEC_MUTE("Capture Switch", 0x14, 0, HDA_OUTPUT), 857 HDA_CODEC_VOLUME("Capture Mux Volume", 0x0f, 0, HDA_OUTPUT), 858 { } /* end */ 859 }; 860 861 static struct snd_kcontrol_new stac9205_mixer[] = { 862 STAC_INPUT_SOURCE(2), 863 STAC_ANALOG_LOOPBACK(0xFE0, 0x7E0, 1), 864 865 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x1b, 0x0, HDA_INPUT), 866 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1d, 0x0, HDA_OUTPUT), 867 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x19, 0x0, HDA_OUTPUT), 868 869 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x1c, 0x0, HDA_INPUT), 870 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1e, 0x0, HDA_OUTPUT), 871 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x1A, 0x0, HDA_OUTPUT), 872 873 { } /* end */ 874 }; 875 876 /* This needs to be generated dynamically based on sequence */ 877 static struct snd_kcontrol_new stac922x_mixer[] = { 878 STAC_INPUT_SOURCE(2), 879 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x17, 0x0, HDA_INPUT), 880 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x17, 0x0, HDA_INPUT), 881 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x12, 0x0, HDA_OUTPUT), 882 883 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x18, 0x0, HDA_INPUT), 884 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x18, 0x0, HDA_INPUT), 885 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x13, 0x0, HDA_OUTPUT), 886 { } /* end */ 887 }; 888 889 890 static struct snd_kcontrol_new stac927x_mixer[] = { 891 STAC_INPUT_SOURCE(3), 892 STAC_ANALOG_LOOPBACK(0xFEB, 0x7EB, 1), 893 894 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x0, 0x18, 0x0, HDA_INPUT), 895 HDA_CODEC_MUTE_IDX("Capture Switch", 0x0, 0x1b, 0x0, HDA_OUTPUT), 896 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x0, 0x15, 0x0, HDA_OUTPUT), 897 898 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x1, 0x19, 0x0, HDA_INPUT), 899 HDA_CODEC_MUTE_IDX("Capture Switch", 0x1, 0x1c, 0x0, HDA_OUTPUT), 900 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x1, 0x16, 0x0, HDA_OUTPUT), 901 902 HDA_CODEC_VOLUME_IDX("Capture Volume", 0x2, 0x1A, 0x0, HDA_INPUT), 903 HDA_CODEC_MUTE_IDX("Capture Switch", 0x2, 0x1d, 0x0, HDA_OUTPUT), 904 HDA_CODEC_VOLUME_IDX("Mux Capture Volume", 0x2, 0x17, 0x0, HDA_OUTPUT), 905 { } /* end */ 906 }; 907 908 static struct snd_kcontrol_new stac_dmux_mixer = { 909 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 910 .name = "Digital Input Source", 911 /* count set later */ 912 .info = stac92xx_dmux_enum_info, 913 .get = stac92xx_dmux_enum_get, 914 .put = stac92xx_dmux_enum_put, 915 }; 916 917 static const char *slave_vols[] = { 918 "Front Playback Volume", 919 "Surround Playback Volume", 920 "Center Playback Volume", 921 "LFE Playback Volume", 922 "Side Playback Volume", 923 "Headphone Playback Volume", 924 "Headphone Playback Volume", 925 "Speaker Playback Volume", 926 "External Speaker Playback Volume", 927 "Speaker2 Playback Volume", 928 NULL 929 }; 930 931 static const char *slave_sws[] = { 932 "Front Playback Switch", 933 "Surround Playback Switch", 934 "Center Playback Switch", 935 "LFE Playback Switch", 936 "Side Playback Switch", 937 "Headphone Playback Switch", 938 "Headphone Playback Switch", 939 "Speaker Playback Switch", 940 "External Speaker Playback Switch", 941 "Speaker2 Playback Switch", 942 "IEC958 Playback Switch", 943 NULL 944 }; 945 946 static int stac92xx_build_controls(struct hda_codec *codec) 947 { 948 struct sigmatel_spec *spec = codec->spec; 949 int err; 950 int i; 951 952 err = snd_hda_add_new_ctls(codec, spec->mixer); 953 if (err < 0) 954 return err; 955 956 for (i = 0; i < spec->num_mixers; i++) { 957 err = snd_hda_add_new_ctls(codec, spec->mixers[i]); 958 if (err < 0) 959 return err; 960 } 961 if (spec->num_dmuxes > 0) { 962 stac_dmux_mixer.count = spec->num_dmuxes; 963 err = snd_ctl_add(codec->bus->card, 964 snd_ctl_new1(&stac_dmux_mixer, codec)); 965 if (err < 0) 966 return err; 967 } 968 969 if (spec->multiout.dig_out_nid) { 970 err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid); 971 if (err < 0) 972 return err; 973 err = snd_hda_create_spdif_share_sw(codec, 974 &spec->multiout); 975 if (err < 0) 976 return err; 977 spec->multiout.share_spdif = 1; 978 } 979 if (spec->dig_in_nid) { 980 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid); 981 if (err < 0) 982 return err; 983 } 984 985 /* if we have no master control, let's create it */ 986 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) { 987 unsigned int vmaster_tlv[4]; 988 snd_hda_set_vmaster_tlv(codec, spec->multiout.dac_nids[0], 989 HDA_OUTPUT, vmaster_tlv); 990 err = snd_hda_add_vmaster(codec, "Master Playback Volume", 991 vmaster_tlv, slave_vols); 992 if (err < 0) 993 return err; 994 } 995 if (!snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) { 996 err = snd_hda_add_vmaster(codec, "Master Playback Switch", 997 NULL, slave_sws); 998 if (err < 0) 999 return err; 1000 } 1001 1002 return 0; 1003 } 1004 1005 static unsigned int ref9200_pin_configs[8] = { 1006 0x01c47010, 0x01447010, 0x0221401f, 0x01114010, 1007 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, 1008 }; 1009 1010 /* 1011 STAC 9200 pin configs for 1012 102801A8 1013 102801DE 1014 102801E8 1015 */ 1016 static unsigned int dell9200_d21_pin_configs[8] = { 1017 0x400001f0, 0x400001f1, 0x02214030, 0x01014010, 1018 0x02a19020, 0x01a19021, 0x90100140, 0x01813122, 1019 }; 1020 1021 /* 1022 STAC 9200 pin configs for 1023 102801C0 1024 102801C1 1025 */ 1026 static unsigned int dell9200_d22_pin_configs[8] = { 1027 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 1028 0x01813020, 0x02a19021, 0x90100140, 0x400001f2, 1029 }; 1030 1031 /* 1032 STAC 9200 pin configs for 1033 102801C4 (Dell Dimension E310) 1034 102801C5 1035 102801C7 1036 102801D9 1037 102801DA 1038 102801E3 1039 */ 1040 static unsigned int dell9200_d23_pin_configs[8] = { 1041 0x400001f0, 0x400001f1, 0x0221401f, 0x01014010, 1042 0x01813020, 0x01a19021, 0x90100140, 0x400001f2, 1043 }; 1044 1045 1046 /* 1047 STAC 9200-32 pin configs for 1048 102801B5 (Dell Inspiron 630m) 1049 102801D8 (Dell Inspiron 640m) 1050 */ 1051 static unsigned int dell9200_m21_pin_configs[8] = { 1052 0x40c003fa, 0x03441340, 0x0321121f, 0x90170310, 1053 0x408003fb, 0x03a11020, 0x401003fc, 0x403003fd, 1054 }; 1055 1056 /* 1057 STAC 9200-32 pin configs for 1058 102801C2 (Dell Latitude D620) 1059 102801C8 1060 102801CC (Dell Latitude D820) 1061 102801D4 1062 102801D6 1063 */ 1064 static unsigned int dell9200_m22_pin_configs[8] = { 1065 0x40c003fa, 0x0144131f, 0x0321121f, 0x90170310, 1066 0x90a70321, 0x03a11020, 0x401003fb, 0x40f000fc, 1067 }; 1068 1069 /* 1070 STAC 9200-32 pin configs for 1071 102801CE (Dell XPS M1710) 1072 102801CF (Dell Precision M90) 1073 */ 1074 static unsigned int dell9200_m23_pin_configs[8] = { 1075 0x40c003fa, 0x01441340, 0x0421421f, 0x90170310, 1076 0x408003fb, 0x04a1102e, 0x90170311, 0x403003fc, 1077 }; 1078 1079 /* 1080 STAC 9200-32 pin configs for 1081 102801C9 1082 102801CA 1083 102801CB (Dell Latitude 120L) 1084 102801D3 1085 */ 1086 static unsigned int dell9200_m24_pin_configs[8] = { 1087 0x40c003fa, 0x404003fb, 0x0321121f, 0x90170310, 1088 0x408003fc, 0x03a11020, 0x401003fd, 0x403003fe, 1089 }; 1090 1091 /* 1092 STAC 9200-32 pin configs for 1093 102801BD (Dell Inspiron E1505n) 1094 102801EE 1095 102801EF 1096 */ 1097 static unsigned int dell9200_m25_pin_configs[8] = { 1098 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 1099 0x408003fb, 0x04a11020, 0x401003fc, 0x403003fd, 1100 }; 1101 1102 /* 1103 STAC 9200-32 pin configs for 1104 102801F5 (Dell Inspiron 1501) 1105 102801F6 1106 */ 1107 static unsigned int dell9200_m26_pin_configs[8] = { 1108 0x40c003fa, 0x404003fb, 0x0421121f, 0x90170310, 1109 0x408003fc, 0x04a11020, 0x401003fd, 0x403003fe, 1110 }; 1111 1112 /* 1113 STAC 9200-32 1114 102801CD (Dell Inspiron E1705/9400) 1115 */ 1116 static unsigned int dell9200_m27_pin_configs[8] = { 1117 0x40c003fa, 0x01441340, 0x0421121f, 0x90170310, 1118 0x90170310, 0x04a11020, 0x90170310, 0x40f003fc, 1119 }; 1120 1121 static unsigned int oqo9200_pin_configs[8] = { 1122 0x40c000f0, 0x404000f1, 0x0221121f, 0x02211210, 1123 0x90170111, 0x90a70120, 0x400000f2, 0x400000f3, 1124 }; 1125 1126 1127 static unsigned int *stac9200_brd_tbl[STAC_9200_MODELS] = { 1128 [STAC_REF] = ref9200_pin_configs, 1129 [STAC_9200_OQO] = oqo9200_pin_configs, 1130 [STAC_9200_DELL_D21] = dell9200_d21_pin_configs, 1131 [STAC_9200_DELL_D22] = dell9200_d22_pin_configs, 1132 [STAC_9200_DELL_D23] = dell9200_d23_pin_configs, 1133 [STAC_9200_DELL_M21] = dell9200_m21_pin_configs, 1134 [STAC_9200_DELL_M22] = dell9200_m22_pin_configs, 1135 [STAC_9200_DELL_M23] = dell9200_m23_pin_configs, 1136 [STAC_9200_DELL_M24] = dell9200_m24_pin_configs, 1137 [STAC_9200_DELL_M25] = dell9200_m25_pin_configs, 1138 [STAC_9200_DELL_M26] = dell9200_m26_pin_configs, 1139 [STAC_9200_DELL_M27] = dell9200_m27_pin_configs, 1140 [STAC_9200_PANASONIC] = ref9200_pin_configs, 1141 }; 1142 1143 static const char *stac9200_models[STAC_9200_MODELS] = { 1144 [STAC_REF] = "ref", 1145 [STAC_9200_OQO] = "oqo", 1146 [STAC_9200_DELL_D21] = "dell-d21", 1147 [STAC_9200_DELL_D22] = "dell-d22", 1148 [STAC_9200_DELL_D23] = "dell-d23", 1149 [STAC_9200_DELL_M21] = "dell-m21", 1150 [STAC_9200_DELL_M22] = "dell-m22", 1151 [STAC_9200_DELL_M23] = "dell-m23", 1152 [STAC_9200_DELL_M24] = "dell-m24", 1153 [STAC_9200_DELL_M25] = "dell-m25", 1154 [STAC_9200_DELL_M26] = "dell-m26", 1155 [STAC_9200_DELL_M27] = "dell-m27", 1156 [STAC_9200_GATEWAY] = "gateway", 1157 [STAC_9200_PANASONIC] = "panasonic", 1158 }; 1159 1160 static struct snd_pci_quirk stac9200_cfg_tbl[] = { 1161 /* SigmaTel reference board */ 1162 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1163 "DFI LanParty", STAC_REF), 1164 /* Dell laptops have BIOS problem */ 1165 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a8, 1166 "unknown Dell", STAC_9200_DELL_D21), 1167 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01b5, 1168 "Dell Inspiron 630m", STAC_9200_DELL_M21), 1169 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bd, 1170 "Dell Inspiron E1505n", STAC_9200_DELL_M25), 1171 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c0, 1172 "unknown Dell", STAC_9200_DELL_D22), 1173 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c1, 1174 "unknown Dell", STAC_9200_DELL_D22), 1175 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c2, 1176 "Dell Latitude D620", STAC_9200_DELL_M22), 1177 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c5, 1178 "unknown Dell", STAC_9200_DELL_D23), 1179 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c7, 1180 "unknown Dell", STAC_9200_DELL_D23), 1181 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c8, 1182 "unknown Dell", STAC_9200_DELL_M22), 1183 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01c9, 1184 "unknown Dell", STAC_9200_DELL_M24), 1185 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ca, 1186 "unknown Dell", STAC_9200_DELL_M24), 1187 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cb, 1188 "Dell Latitude 120L", STAC_9200_DELL_M24), 1189 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cc, 1190 "Dell Latitude D820", STAC_9200_DELL_M22), 1191 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cd, 1192 "Dell Inspiron E1705/9400", STAC_9200_DELL_M27), 1193 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ce, 1194 "Dell XPS M1710", STAC_9200_DELL_M23), 1195 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01cf, 1196 "Dell Precision M90", STAC_9200_DELL_M23), 1197 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d3, 1198 "unknown Dell", STAC_9200_DELL_M22), 1199 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d4, 1200 "unknown Dell", STAC_9200_DELL_M22), 1201 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d6, 1202 "unknown Dell", STAC_9200_DELL_M22), 1203 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d8, 1204 "Dell Inspiron 640m", STAC_9200_DELL_M21), 1205 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d9, 1206 "unknown Dell", STAC_9200_DELL_D23), 1207 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01da, 1208 "unknown Dell", STAC_9200_DELL_D23), 1209 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01de, 1210 "unknown Dell", STAC_9200_DELL_D21), 1211 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e3, 1212 "unknown Dell", STAC_9200_DELL_D23), 1213 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01e8, 1214 "unknown Dell", STAC_9200_DELL_D21), 1215 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ee, 1216 "unknown Dell", STAC_9200_DELL_M25), 1217 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ef, 1218 "unknown Dell", STAC_9200_DELL_M25), 1219 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f5, 1220 "Dell Inspiron 1501", STAC_9200_DELL_M26), 1221 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f6, 1222 "unknown Dell", STAC_9200_DELL_M26), 1223 /* Panasonic */ 1224 SND_PCI_QUIRK(0x10f7, 0x8338, "Panasonic CF-74", STAC_9200_PANASONIC), 1225 /* Gateway machines needs EAPD to be set on resume */ 1226 SND_PCI_QUIRK(0x107b, 0x0205, "Gateway S-7110M", STAC_9200_GATEWAY), 1227 SND_PCI_QUIRK(0x107b, 0x0317, "Gateway MT3423, MX341*", 1228 STAC_9200_GATEWAY), 1229 SND_PCI_QUIRK(0x107b, 0x0318, "Gateway ML3019, MT3707", 1230 STAC_9200_GATEWAY), 1231 /* OQO Mobile */ 1232 SND_PCI_QUIRK(0x1106, 0x3288, "OQO Model 2", STAC_9200_OQO), 1233 {} /* terminator */ 1234 }; 1235 1236 static unsigned int ref925x_pin_configs[8] = { 1237 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021, 1238 0x90a70320, 0x02214210, 0x01019020, 0x9033032e, 1239 }; 1240 1241 static unsigned int stac925x_MA6_pin_configs[8] = { 1242 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021, 1243 0x90a70320, 0x90100211, 0x400003f1, 0x9033032e, 1244 }; 1245 1246 static unsigned int stac925x_PA6_pin_configs[8] = { 1247 0x40c003f0, 0x424503f2, 0x01813022, 0x02a19021, 1248 0x50a103f0, 0x90100211, 0x400003f1, 0x9033032e, 1249 }; 1250 1251 static unsigned int stac925xM2_2_pin_configs[8] = { 1252 0x40c003f3, 0x424503f2, 0x04180011, 0x02a19020, 1253 0x50a103f0, 0x90100212, 0x400003f1, 0x9033032e, 1254 }; 1255 1256 static unsigned int *stac925x_brd_tbl[STAC_925x_MODELS] = { 1257 [STAC_REF] = ref925x_pin_configs, 1258 [STAC_M2_2] = stac925xM2_2_pin_configs, 1259 [STAC_MA6] = stac925x_MA6_pin_configs, 1260 [STAC_PA6] = stac925x_PA6_pin_configs, 1261 }; 1262 1263 static const char *stac925x_models[STAC_925x_MODELS] = { 1264 [STAC_REF] = "ref", 1265 [STAC_M2_2] = "m2-2", 1266 [STAC_MA6] = "m6", 1267 [STAC_PA6] = "pa6", 1268 }; 1269 1270 static struct snd_pci_quirk stac925x_cfg_tbl[] = { 1271 /* SigmaTel reference board */ 1272 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, "DFI LanParty", STAC_REF), 1273 SND_PCI_QUIRK(0x8384, 0x7632, "Stac9202 Reference Board", STAC_REF), 1274 SND_PCI_QUIRK(0x107b, 0x0316, "Gateway M255", STAC_REF), 1275 SND_PCI_QUIRK(0x107b, 0x0366, "Gateway MP6954", STAC_REF), 1276 SND_PCI_QUIRK(0x107b, 0x0461, "Gateway NX560XL", STAC_MA6), 1277 SND_PCI_QUIRK(0x107b, 0x0681, "Gateway NX860", STAC_PA6), 1278 SND_PCI_QUIRK(0x1002, 0x437b, "Gateway MX6453", STAC_M2_2), 1279 {} /* terminator */ 1280 }; 1281 1282 static unsigned int ref92hd73xx_pin_configs[13] = { 1283 0x02214030, 0x02a19040, 0x01a19020, 0x02214030, 1284 0x0181302e, 0x01014010, 0x01014020, 0x01014030, 1285 0x02319040, 0x90a000f0, 0x90a000f0, 0x01452050, 1286 0x01452050, 1287 }; 1288 1289 static unsigned int dell_m6_pin_configs[13] = { 1290 0x0321101f, 0x4f00000f, 0x4f0000f0, 0x90170110, 1291 0x03a11020, 0x0321101f, 0x4f0000f0, 0x4f0000f0, 1292 0x4f0000f0, 0x90a60160, 0x4f0000f0, 0x4f0000f0, 1293 0x4f0000f0, 1294 }; 1295 1296 static unsigned int *stac92hd73xx_brd_tbl[STAC_92HD73XX_MODELS] = { 1297 [STAC_92HD73XX_REF] = ref92hd73xx_pin_configs, 1298 [STAC_DELL_M6] = dell_m6_pin_configs, 1299 }; 1300 1301 static const char *stac92hd73xx_models[STAC_92HD73XX_MODELS] = { 1302 [STAC_92HD73XX_REF] = "ref", 1303 [STAC_DELL_M6] = "dell-m6", 1304 }; 1305 1306 static struct snd_pci_quirk stac92hd73xx_cfg_tbl[] = { 1307 /* SigmaTel reference board */ 1308 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1309 "DFI LanParty", STAC_92HD73XX_REF), 1310 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0254, 1311 "unknown Dell", STAC_DELL_M6), 1312 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0255, 1313 "unknown Dell", STAC_DELL_M6), 1314 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0256, 1315 "unknown Dell", STAC_DELL_M6), 1316 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0257, 1317 "unknown Dell", STAC_DELL_M6), 1318 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025e, 1319 "unknown Dell", STAC_DELL_M6), 1320 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x025f, 1321 "unknown Dell", STAC_DELL_M6), 1322 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0271, 1323 "unknown Dell", STAC_DELL_M6), 1324 {} /* terminator */ 1325 }; 1326 1327 static unsigned int ref92hd71bxx_pin_configs[10] = { 1328 0x02214030, 0x02a19040, 0x01a19020, 0x01014010, 1329 0x0181302e, 0x01114010, 0x01019020, 0x90a000f0, 1330 0x90a000f0, 0x01452050, 1331 }; 1332 1333 static unsigned int dell_m4_1_pin_configs[10] = { 1334 0x0421101f, 0x04a11221, 0x40f000f0, 0x90170110, 1335 0x23a1902e, 0x23014250, 0x40f000f0, 0x90a000f0, 1336 0x40f000f0, 0x4f0000f0, 1337 }; 1338 1339 static unsigned int dell_m4_2_pin_configs[10] = { 1340 0x0421101f, 0x04a11221, 0x90a70330, 0x90170110, 1341 0x23a1902e, 0x23014250, 0x40f000f0, 0x40f000f0, 1342 0x40f000f0, 0x044413b0, 1343 }; 1344 1345 static unsigned int *stac92hd71bxx_brd_tbl[STAC_92HD71BXX_MODELS] = { 1346 [STAC_92HD71BXX_REF] = ref92hd71bxx_pin_configs, 1347 [STAC_DELL_M4_1] = dell_m4_1_pin_configs, 1348 [STAC_DELL_M4_2] = dell_m4_2_pin_configs, 1349 }; 1350 1351 static const char *stac92hd71bxx_models[STAC_92HD71BXX_MODELS] = { 1352 [STAC_92HD71BXX_REF] = "ref", 1353 [STAC_DELL_M4_1] = "dell-m4-1", 1354 [STAC_DELL_M4_2] = "dell-m4-2", 1355 }; 1356 1357 static struct snd_pci_quirk stac92hd71bxx_cfg_tbl[] = { 1358 /* SigmaTel reference board */ 1359 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1360 "DFI LanParty", STAC_92HD71BXX_REF), 1361 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0233, 1362 "unknown Dell", STAC_DELL_M4_1), 1363 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0234, 1364 "unknown Dell", STAC_DELL_M4_1), 1365 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0250, 1366 "unknown Dell", STAC_DELL_M4_1), 1367 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024f, 1368 "unknown Dell", STAC_DELL_M4_1), 1369 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x024d, 1370 "unknown Dell", STAC_DELL_M4_1), 1371 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0251, 1372 "unknown Dell", STAC_DELL_M4_1), 1373 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0277, 1374 "unknown Dell", STAC_DELL_M4_1), 1375 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0263, 1376 "unknown Dell", STAC_DELL_M4_2), 1377 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0265, 1378 "unknown Dell", STAC_DELL_M4_2), 1379 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0262, 1380 "unknown Dell", STAC_DELL_M4_2), 1381 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0264, 1382 "unknown Dell", STAC_DELL_M4_2), 1383 {} /* terminator */ 1384 }; 1385 1386 static unsigned int ref922x_pin_configs[10] = { 1387 0x01014010, 0x01016011, 0x01012012, 0x0221401f, 1388 0x01813122, 0x01011014, 0x01441030, 0x01c41030, 1389 0x40000100, 0x40000100, 1390 }; 1391 1392 /* 1393 STAC 922X pin configs for 1394 102801A7 1395 102801AB 1396 102801A9 1397 102801D1 1398 102801D2 1399 */ 1400 static unsigned int dell_922x_d81_pin_configs[10] = { 1401 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1402 0x02a19020, 0x01117011, 0x400001f0, 0x400001f1, 1403 0x01813122, 0x400001f2, 1404 }; 1405 1406 /* 1407 STAC 922X pin configs for 1408 102801AC 1409 102801D0 1410 */ 1411 static unsigned int dell_922x_d82_pin_configs[10] = { 1412 0x02214030, 0x01a19021, 0x01111012, 0x01114010, 1413 0x02a19020, 0x01117011, 0x01451140, 0x400001f0, 1414 0x01813122, 0x400001f1, 1415 }; 1416 1417 /* 1418 STAC 922X pin configs for 1419 102801BF 1420 */ 1421 static unsigned int dell_922x_m81_pin_configs[10] = { 1422 0x0321101f, 0x01112024, 0x01111222, 0x91174220, 1423 0x03a11050, 0x01116221, 0x90a70330, 0x01452340, 1424 0x40C003f1, 0x405003f0, 1425 }; 1426 1427 /* 1428 STAC 9221 A1 pin configs for 1429 102801D7 (Dell XPS M1210) 1430 */ 1431 static unsigned int dell_922x_m82_pin_configs[10] = { 1432 0x02211211, 0x408103ff, 0x02a1123e, 0x90100310, 1433 0x408003f1, 0x0221121f, 0x03451340, 0x40c003f2, 1434 0x508003f3, 0x405003f4, 1435 }; 1436 1437 static unsigned int d945gtp3_pin_configs[10] = { 1438 0x0221401f, 0x01a19022, 0x01813021, 0x01014010, 1439 0x40000100, 0x40000100, 0x40000100, 0x40000100, 1440 0x02a19120, 0x40000100, 1441 }; 1442 1443 static unsigned int d945gtp5_pin_configs[10] = { 1444 0x0221401f, 0x01011012, 0x01813024, 0x01014010, 1445 0x01a19021, 0x01016011, 0x01452130, 0x40000100, 1446 0x02a19320, 0x40000100, 1447 }; 1448 1449 static unsigned int intel_mac_v1_pin_configs[10] = { 1450 0x0121e21f, 0x400000ff, 0x9017e110, 0x400000fd, 1451 0x400000fe, 0x0181e020, 0x1145e030, 0x11c5e240, 1452 0x400000fc, 0x400000fb, 1453 }; 1454 1455 static unsigned int intel_mac_v2_pin_configs[10] = { 1456 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1457 0x400000fe, 0x0181e020, 0x1145e230, 0x500000fa, 1458 0x400000fc, 0x400000fb, 1459 }; 1460 1461 static unsigned int intel_mac_v3_pin_configs[10] = { 1462 0x0121e21f, 0x90a7012e, 0x9017e110, 0x400000fd, 1463 0x400000fe, 0x0181e020, 0x1145e230, 0x11c5e240, 1464 0x400000fc, 0x400000fb, 1465 }; 1466 1467 static unsigned int intel_mac_v4_pin_configs[10] = { 1468 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1469 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1470 0x400000fc, 0x400000fb, 1471 }; 1472 1473 static unsigned int intel_mac_v5_pin_configs[10] = { 1474 0x0321e21f, 0x03a1e02e, 0x9017e110, 0x9017e11f, 1475 0x400000fe, 0x0381e020, 0x1345e230, 0x13c5e240, 1476 0x400000fc, 0x400000fb, 1477 }; 1478 1479 1480 static unsigned int *stac922x_brd_tbl[STAC_922X_MODELS] = { 1481 [STAC_D945_REF] = ref922x_pin_configs, 1482 [STAC_D945GTP3] = d945gtp3_pin_configs, 1483 [STAC_D945GTP5] = d945gtp5_pin_configs, 1484 [STAC_INTEL_MAC_V1] = intel_mac_v1_pin_configs, 1485 [STAC_INTEL_MAC_V2] = intel_mac_v2_pin_configs, 1486 [STAC_INTEL_MAC_V3] = intel_mac_v3_pin_configs, 1487 [STAC_INTEL_MAC_V4] = intel_mac_v4_pin_configs, 1488 [STAC_INTEL_MAC_V5] = intel_mac_v5_pin_configs, 1489 [STAC_INTEL_MAC_AUTO] = intel_mac_v3_pin_configs, 1490 /* for backward compatibility */ 1491 [STAC_MACMINI] = intel_mac_v3_pin_configs, 1492 [STAC_MACBOOK] = intel_mac_v5_pin_configs, 1493 [STAC_MACBOOK_PRO_V1] = intel_mac_v3_pin_configs, 1494 [STAC_MACBOOK_PRO_V2] = intel_mac_v3_pin_configs, 1495 [STAC_IMAC_INTEL] = intel_mac_v2_pin_configs, 1496 [STAC_IMAC_INTEL_20] = intel_mac_v3_pin_configs, 1497 [STAC_922X_DELL_D81] = dell_922x_d81_pin_configs, 1498 [STAC_922X_DELL_D82] = dell_922x_d82_pin_configs, 1499 [STAC_922X_DELL_M81] = dell_922x_m81_pin_configs, 1500 [STAC_922X_DELL_M82] = dell_922x_m82_pin_configs, 1501 }; 1502 1503 static const char *stac922x_models[STAC_922X_MODELS] = { 1504 [STAC_D945_REF] = "ref", 1505 [STAC_D945GTP5] = "5stack", 1506 [STAC_D945GTP3] = "3stack", 1507 [STAC_INTEL_MAC_V1] = "intel-mac-v1", 1508 [STAC_INTEL_MAC_V2] = "intel-mac-v2", 1509 [STAC_INTEL_MAC_V3] = "intel-mac-v3", 1510 [STAC_INTEL_MAC_V4] = "intel-mac-v4", 1511 [STAC_INTEL_MAC_V5] = "intel-mac-v5", 1512 [STAC_INTEL_MAC_AUTO] = "intel-mac-auto", 1513 /* for backward compatibility */ 1514 [STAC_MACMINI] = "macmini", 1515 [STAC_MACBOOK] = "macbook", 1516 [STAC_MACBOOK_PRO_V1] = "macbook-pro-v1", 1517 [STAC_MACBOOK_PRO_V2] = "macbook-pro", 1518 [STAC_IMAC_INTEL] = "imac-intel", 1519 [STAC_IMAC_INTEL_20] = "imac-intel-20", 1520 [STAC_922X_DELL_D81] = "dell-d81", 1521 [STAC_922X_DELL_D82] = "dell-d82", 1522 [STAC_922X_DELL_M81] = "dell-m81", 1523 [STAC_922X_DELL_M82] = "dell-m82", 1524 }; 1525 1526 static struct snd_pci_quirk stac922x_cfg_tbl[] = { 1527 /* SigmaTel reference board */ 1528 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1529 "DFI LanParty", STAC_D945_REF), 1530 /* Intel 945G based systems */ 1531 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0101, 1532 "Intel D945G", STAC_D945GTP3), 1533 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0202, 1534 "Intel D945G", STAC_D945GTP3), 1535 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0606, 1536 "Intel D945G", STAC_D945GTP3), 1537 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0601, 1538 "Intel D945G", STAC_D945GTP3), 1539 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0111, 1540 "Intel D945G", STAC_D945GTP3), 1541 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1115, 1542 "Intel D945G", STAC_D945GTP3), 1543 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1116, 1544 "Intel D945G", STAC_D945GTP3), 1545 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1117, 1546 "Intel D945G", STAC_D945GTP3), 1547 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1118, 1548 "Intel D945G", STAC_D945GTP3), 1549 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x1119, 1550 "Intel D945G", STAC_D945GTP3), 1551 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x8826, 1552 "Intel D945G", STAC_D945GTP3), 1553 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5049, 1554 "Intel D945G", STAC_D945GTP3), 1555 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5055, 1556 "Intel D945G", STAC_D945GTP3), 1557 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x5048, 1558 "Intel D945G", STAC_D945GTP3), 1559 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0110, 1560 "Intel D945G", STAC_D945GTP3), 1561 /* Intel D945G 5-stack systems */ 1562 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0404, 1563 "Intel D945G", STAC_D945GTP5), 1564 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0303, 1565 "Intel D945G", STAC_D945GTP5), 1566 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0013, 1567 "Intel D945G", STAC_D945GTP5), 1568 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0417, 1569 "Intel D945G", STAC_D945GTP5), 1570 /* Intel 945P based systems */ 1571 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0b0b, 1572 "Intel D945P", STAC_D945GTP3), 1573 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0112, 1574 "Intel D945P", STAC_D945GTP3), 1575 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0d0d, 1576 "Intel D945P", STAC_D945GTP3), 1577 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0909, 1578 "Intel D945P", STAC_D945GTP3), 1579 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0505, 1580 "Intel D945P", STAC_D945GTP3), 1581 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x0707, 1582 "Intel D945P", STAC_D945GTP5), 1583 /* other systems */ 1584 /* Apple Intel Mac (Mac Mini, MacBook, MacBook Pro...) */ 1585 SND_PCI_QUIRK(0x8384, 0x7680, 1586 "Mac", STAC_INTEL_MAC_AUTO), 1587 /* Dell systems */ 1588 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a7, 1589 "unknown Dell", STAC_922X_DELL_D81), 1590 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01a9, 1591 "unknown Dell", STAC_922X_DELL_D81), 1592 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ab, 1593 "unknown Dell", STAC_922X_DELL_D81), 1594 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ac, 1595 "unknown Dell", STAC_922X_DELL_D82), 1596 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01bf, 1597 "unknown Dell", STAC_922X_DELL_M81), 1598 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d0, 1599 "unknown Dell", STAC_922X_DELL_D82), 1600 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d1, 1601 "unknown Dell", STAC_922X_DELL_D81), 1602 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d2, 1603 "unknown Dell", STAC_922X_DELL_D81), 1604 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01d7, 1605 "Dell XPS M1210", STAC_922X_DELL_M82), 1606 {} /* terminator */ 1607 }; 1608 1609 static unsigned int ref927x_pin_configs[14] = { 1610 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 1611 0x01a19040, 0x01011012, 0x01016011, 0x0101201f, 1612 0x183301f0, 0x18a001f0, 0x18a001f0, 0x01442070, 1613 0x01c42190, 0x40000100, 1614 }; 1615 1616 static unsigned int d965_3st_pin_configs[14] = { 1617 0x0221401f, 0x02a19120, 0x40000100, 0x01014011, 1618 0x01a19021, 0x01813024, 0x40000100, 0x40000100, 1619 0x40000100, 0x40000100, 0x40000100, 0x40000100, 1620 0x40000100, 0x40000100 1621 }; 1622 1623 static unsigned int d965_5st_pin_configs[14] = { 1624 0x02214020, 0x02a19080, 0x0181304e, 0x01014010, 1625 0x01a19040, 0x01011012, 0x01016011, 0x40000100, 1626 0x40000100, 0x40000100, 0x40000100, 0x01442070, 1627 0x40000100, 0x40000100 1628 }; 1629 1630 static unsigned int dell_3st_pin_configs[14] = { 1631 0x02211230, 0x02a11220, 0x01a19040, 0x01114210, 1632 0x01111212, 0x01116211, 0x01813050, 0x01112214, 1633 0x403003fa, 0x90a60040, 0x90a60040, 0x404003fb, 1634 0x40c003fc, 0x40000100 1635 }; 1636 1637 static unsigned int *stac927x_brd_tbl[STAC_927X_MODELS] = { 1638 [STAC_D965_REF] = ref927x_pin_configs, 1639 [STAC_D965_3ST] = d965_3st_pin_configs, 1640 [STAC_D965_5ST] = d965_5st_pin_configs, 1641 [STAC_DELL_3ST] = dell_3st_pin_configs, 1642 [STAC_DELL_BIOS] = NULL, 1643 }; 1644 1645 static const char *stac927x_models[STAC_927X_MODELS] = { 1646 [STAC_D965_REF] = "ref", 1647 [STAC_D965_3ST] = "3stack", 1648 [STAC_D965_5ST] = "5stack", 1649 [STAC_DELL_3ST] = "dell-3stack", 1650 [STAC_DELL_BIOS] = "dell-bios", 1651 }; 1652 1653 static struct snd_pci_quirk stac927x_cfg_tbl[] = { 1654 /* SigmaTel reference board */ 1655 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1656 "DFI LanParty", STAC_D965_REF), 1657 /* Intel 946 based systems */ 1658 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x3d01, "Intel D946", STAC_D965_3ST), 1659 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0xa301, "Intel D946", STAC_D965_3ST), 1660 /* 965 based 3 stack systems */ 1661 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2116, "Intel D965", STAC_D965_3ST), 1662 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2115, "Intel D965", STAC_D965_3ST), 1663 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2114, "Intel D965", STAC_D965_3ST), 1664 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2113, "Intel D965", STAC_D965_3ST), 1665 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2112, "Intel D965", STAC_D965_3ST), 1666 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2111, "Intel D965", STAC_D965_3ST), 1667 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2110, "Intel D965", STAC_D965_3ST), 1668 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2009, "Intel D965", STAC_D965_3ST), 1669 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2008, "Intel D965", STAC_D965_3ST), 1670 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2007, "Intel D965", STAC_D965_3ST), 1671 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2006, "Intel D965", STAC_D965_3ST), 1672 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2005, "Intel D965", STAC_D965_3ST), 1673 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2004, "Intel D965", STAC_D965_3ST), 1674 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2003, "Intel D965", STAC_D965_3ST), 1675 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2002, "Intel D965", STAC_D965_3ST), 1676 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2001, "Intel D965", STAC_D965_3ST), 1677 /* Dell 3 stack systems */ 1678 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f7, "Dell XPS M1730", STAC_DELL_3ST), 1679 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01dd, "Dell Dimension E520", STAC_DELL_3ST), 1680 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ed, "Dell ", STAC_DELL_3ST), 1681 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f4, "Dell ", STAC_DELL_3ST), 1682 /* Dell 3 stack systems with verb table in BIOS */ 1683 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f3, "Dell Inspiron 1420", STAC_DELL_BIOS), 1684 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0227, "Dell Vostro 1400 ", STAC_DELL_BIOS), 1685 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022f, "Dell ", STAC_DELL_BIOS), 1686 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x022e, "Dell ", STAC_DELL_BIOS), 1687 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0242, "Dell ", STAC_DELL_BIOS), 1688 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0243, "Dell ", STAC_DELL_BIOS), 1689 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x02ff, "Dell ", STAC_DELL_BIOS), 1690 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0209, "Dell XPS 1330", STAC_DELL_BIOS), 1691 /* 965 based 5 stack systems */ 1692 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2301, "Intel D965", STAC_D965_5ST), 1693 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2302, "Intel D965", STAC_D965_5ST), 1694 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2303, "Intel D965", STAC_D965_5ST), 1695 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2304, "Intel D965", STAC_D965_5ST), 1696 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2305, "Intel D965", STAC_D965_5ST), 1697 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2501, "Intel D965", STAC_D965_5ST), 1698 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2502, "Intel D965", STAC_D965_5ST), 1699 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2503, "Intel D965", STAC_D965_5ST), 1700 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2504, "Intel D965", STAC_D965_5ST), 1701 {} /* terminator */ 1702 }; 1703 1704 static unsigned int ref9205_pin_configs[12] = { 1705 0x40000100, 0x40000100, 0x01016011, 0x01014010, 1706 0x01813122, 0x01a19021, 0x01019020, 0x40000100, 1707 0x90a000f0, 0x90a000f0, 0x01441030, 0x01c41030 1708 }; 1709 1710 /* 1711 STAC 9205 pin configs for 1712 102801F1 1713 102801F2 1714 102801FC 1715 102801FD 1716 10280204 1717 1028021F 1718 10280228 (Dell Vostro 1500) 1719 */ 1720 static unsigned int dell_9205_m42_pin_configs[12] = { 1721 0x0321101F, 0x03A11020, 0x400003FA, 0x90170310, 1722 0x400003FB, 0x400003FC, 0x400003FD, 0x40F000F9, 1723 0x90A60330, 0x400003FF, 0x0144131F, 0x40C003FE, 1724 }; 1725 1726 /* 1727 STAC 9205 pin configs for 1728 102801F9 1729 102801FA 1730 102801FE 1731 102801FF (Dell Precision M4300) 1732 10280206 1733 10280200 1734 10280201 1735 */ 1736 static unsigned int dell_9205_m43_pin_configs[12] = { 1737 0x0321101f, 0x03a11020, 0x90a70330, 0x90170310, 1738 0x400000fe, 0x400000ff, 0x400000fd, 0x40f000f9, 1739 0x400000fa, 0x400000fc, 0x0144131f, 0x40c003f8, 1740 }; 1741 1742 static unsigned int dell_9205_m44_pin_configs[12] = { 1743 0x0421101f, 0x04a11020, 0x400003fa, 0x90170310, 1744 0x400003fb, 0x400003fc, 0x400003fd, 0x400003f9, 1745 0x90a60330, 0x400003ff, 0x01441340, 0x40c003fe, 1746 }; 1747 1748 static unsigned int *stac9205_brd_tbl[STAC_9205_MODELS] = { 1749 [STAC_9205_REF] = ref9205_pin_configs, 1750 [STAC_9205_DELL_M42] = dell_9205_m42_pin_configs, 1751 [STAC_9205_DELL_M43] = dell_9205_m43_pin_configs, 1752 [STAC_9205_DELL_M44] = dell_9205_m44_pin_configs, 1753 }; 1754 1755 static const char *stac9205_models[STAC_9205_MODELS] = { 1756 [STAC_9205_REF] = "ref", 1757 [STAC_9205_DELL_M42] = "dell-m42", 1758 [STAC_9205_DELL_M43] = "dell-m43", 1759 [STAC_9205_DELL_M44] = "dell-m44", 1760 }; 1761 1762 static struct snd_pci_quirk stac9205_cfg_tbl[] = { 1763 /* SigmaTel reference board */ 1764 SND_PCI_QUIRK(PCI_VENDOR_ID_INTEL, 0x2668, 1765 "DFI LanParty", STAC_9205_REF), 1766 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f1, 1767 "unknown Dell", STAC_9205_DELL_M42), 1768 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f2, 1769 "unknown Dell", STAC_9205_DELL_M42), 1770 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f8, 1771 "Dell Precision", STAC_9205_DELL_M43), 1772 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01f9, 1773 "Dell Precision", STAC_9205_DELL_M43), 1774 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fa, 1775 "Dell Precision", STAC_9205_DELL_M43), 1776 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fc, 1777 "unknown Dell", STAC_9205_DELL_M42), 1778 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fd, 1779 "unknown Dell", STAC_9205_DELL_M42), 1780 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01fe, 1781 "Dell Precision", STAC_9205_DELL_M43), 1782 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x01ff, 1783 "Dell Precision M4300", STAC_9205_DELL_M43), 1784 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0204, 1785 "unknown Dell", STAC_9205_DELL_M42), 1786 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0206, 1787 "Dell Precision", STAC_9205_DELL_M43), 1788 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021b, 1789 "Dell Precision", STAC_9205_DELL_M43), 1790 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021c, 1791 "Dell Precision", STAC_9205_DELL_M43), 1792 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x021f, 1793 "Dell Inspiron", STAC_9205_DELL_M44), 1794 SND_PCI_QUIRK(PCI_VENDOR_ID_DELL, 0x0228, 1795 "Dell Vostro 1500", STAC_9205_DELL_M42), 1796 {} /* terminator */ 1797 }; 1798 1799 static int stac92xx_save_bios_config_regs(struct hda_codec *codec) 1800 { 1801 int i; 1802 struct sigmatel_spec *spec = codec->spec; 1803 1804 if (! spec->bios_pin_configs) { 1805 spec->bios_pin_configs = kcalloc(spec->num_pins, 1806 sizeof(*spec->bios_pin_configs), GFP_KERNEL); 1807 if (! spec->bios_pin_configs) 1808 return -ENOMEM; 1809 } 1810 1811 for (i = 0; i < spec->num_pins; i++) { 1812 hda_nid_t nid = spec->pin_nids[i]; 1813 unsigned int pin_cfg; 1814 1815 pin_cfg = snd_hda_codec_read(codec, nid, 0, 1816 AC_VERB_GET_CONFIG_DEFAULT, 0x00); 1817 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x bios pin config %8.8x\n", 1818 nid, pin_cfg); 1819 spec->bios_pin_configs[i] = pin_cfg; 1820 } 1821 1822 return 0; 1823 } 1824 1825 static void stac92xx_set_config_reg(struct hda_codec *codec, 1826 hda_nid_t pin_nid, unsigned int pin_config) 1827 { 1828 int i; 1829 snd_hda_codec_write(codec, pin_nid, 0, 1830 AC_VERB_SET_CONFIG_DEFAULT_BYTES_0, 1831 pin_config & 0x000000ff); 1832 snd_hda_codec_write(codec, pin_nid, 0, 1833 AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 1834 (pin_config & 0x0000ff00) >> 8); 1835 snd_hda_codec_write(codec, pin_nid, 0, 1836 AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 1837 (pin_config & 0x00ff0000) >> 16); 1838 snd_hda_codec_write(codec, pin_nid, 0, 1839 AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 1840 pin_config >> 24); 1841 i = snd_hda_codec_read(codec, pin_nid, 0, 1842 AC_VERB_GET_CONFIG_DEFAULT, 1843 0x00); 1844 snd_printdd(KERN_INFO "hda_codec: pin nid %2.2x pin config %8.8x\n", 1845 pin_nid, i); 1846 } 1847 1848 static void stac92xx_set_config_regs(struct hda_codec *codec) 1849 { 1850 int i; 1851 struct sigmatel_spec *spec = codec->spec; 1852 1853 if (!spec->pin_configs) 1854 return; 1855 1856 for (i = 0; i < spec->num_pins; i++) 1857 stac92xx_set_config_reg(codec, spec->pin_nids[i], 1858 spec->pin_configs[i]); 1859 } 1860 1861 /* 1862 * Analog playback callbacks 1863 */ 1864 static int stac92xx_playback_pcm_open(struct hda_pcm_stream *hinfo, 1865 struct hda_codec *codec, 1866 struct snd_pcm_substream *substream) 1867 { 1868 struct sigmatel_spec *spec = codec->spec; 1869 return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream, 1870 hinfo); 1871 } 1872 1873 static int stac92xx_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 1874 struct hda_codec *codec, 1875 unsigned int stream_tag, 1876 unsigned int format, 1877 struct snd_pcm_substream *substream) 1878 { 1879 struct sigmatel_spec *spec = codec->spec; 1880 return snd_hda_multi_out_analog_prepare(codec, &spec->multiout, stream_tag, format, substream); 1881 } 1882 1883 static int stac92xx_playback_pcm_cleanup(struct hda_pcm_stream *hinfo, 1884 struct hda_codec *codec, 1885 struct snd_pcm_substream *substream) 1886 { 1887 struct sigmatel_spec *spec = codec->spec; 1888 return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout); 1889 } 1890 1891 /* 1892 * Digital playback callbacks 1893 */ 1894 static int stac92xx_dig_playback_pcm_open(struct hda_pcm_stream *hinfo, 1895 struct hda_codec *codec, 1896 struct snd_pcm_substream *substream) 1897 { 1898 struct sigmatel_spec *spec = codec->spec; 1899 return snd_hda_multi_out_dig_open(codec, &spec->multiout); 1900 } 1901 1902 static int stac92xx_dig_playback_pcm_close(struct hda_pcm_stream *hinfo, 1903 struct hda_codec *codec, 1904 struct snd_pcm_substream *substream) 1905 { 1906 struct sigmatel_spec *spec = codec->spec; 1907 return snd_hda_multi_out_dig_close(codec, &spec->multiout); 1908 } 1909 1910 static int stac92xx_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo, 1911 struct hda_codec *codec, 1912 unsigned int stream_tag, 1913 unsigned int format, 1914 struct snd_pcm_substream *substream) 1915 { 1916 struct sigmatel_spec *spec = codec->spec; 1917 return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, 1918 stream_tag, format, substream); 1919 } 1920 1921 1922 /* 1923 * Analog capture callbacks 1924 */ 1925 static int stac92xx_capture_pcm_prepare(struct hda_pcm_stream *hinfo, 1926 struct hda_codec *codec, 1927 unsigned int stream_tag, 1928 unsigned int format, 1929 struct snd_pcm_substream *substream) 1930 { 1931 struct sigmatel_spec *spec = codec->spec; 1932 1933 snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number], 1934 stream_tag, 0, format); 1935 return 0; 1936 } 1937 1938 static int stac92xx_capture_pcm_cleanup(struct hda_pcm_stream *hinfo, 1939 struct hda_codec *codec, 1940 struct snd_pcm_substream *substream) 1941 { 1942 struct sigmatel_spec *spec = codec->spec; 1943 1944 snd_hda_codec_cleanup_stream(codec, spec->adc_nids[substream->number]); 1945 return 0; 1946 } 1947 1948 static struct hda_pcm_stream stac92xx_pcm_digital_playback = { 1949 .substreams = 1, 1950 .channels_min = 2, 1951 .channels_max = 2, 1952 /* NID is set in stac92xx_build_pcms */ 1953 .ops = { 1954 .open = stac92xx_dig_playback_pcm_open, 1955 .close = stac92xx_dig_playback_pcm_close, 1956 .prepare = stac92xx_dig_playback_pcm_prepare 1957 }, 1958 }; 1959 1960 static struct hda_pcm_stream stac92xx_pcm_digital_capture = { 1961 .substreams = 1, 1962 .channels_min = 2, 1963 .channels_max = 2, 1964 /* NID is set in stac92xx_build_pcms */ 1965 }; 1966 1967 static struct hda_pcm_stream stac92xx_pcm_analog_playback = { 1968 .substreams = 1, 1969 .channels_min = 2, 1970 .channels_max = 8, 1971 .nid = 0x02, /* NID to query formats and rates */ 1972 .ops = { 1973 .open = stac92xx_playback_pcm_open, 1974 .prepare = stac92xx_playback_pcm_prepare, 1975 .cleanup = stac92xx_playback_pcm_cleanup 1976 }, 1977 }; 1978 1979 static struct hda_pcm_stream stac92xx_pcm_analog_alt_playback = { 1980 .substreams = 1, 1981 .channels_min = 2, 1982 .channels_max = 2, 1983 .nid = 0x06, /* NID to query formats and rates */ 1984 .ops = { 1985 .open = stac92xx_playback_pcm_open, 1986 .prepare = stac92xx_playback_pcm_prepare, 1987 .cleanup = stac92xx_playback_pcm_cleanup 1988 }, 1989 }; 1990 1991 static struct hda_pcm_stream stac92xx_pcm_analog_capture = { 1992 .channels_min = 2, 1993 .channels_max = 2, 1994 /* NID + .substreams is set in stac92xx_build_pcms */ 1995 .ops = { 1996 .prepare = stac92xx_capture_pcm_prepare, 1997 .cleanup = stac92xx_capture_pcm_cleanup 1998 }, 1999 }; 2000 2001 static int stac92xx_build_pcms(struct hda_codec *codec) 2002 { 2003 struct sigmatel_spec *spec = codec->spec; 2004 struct hda_pcm *info = spec->pcm_rec; 2005 2006 codec->num_pcms = 1; 2007 codec->pcm_info = info; 2008 2009 info->name = "STAC92xx Analog"; 2010 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_playback; 2011 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_analog_capture; 2012 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0]; 2013 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_adcs; 2014 2015 if (spec->alt_switch) { 2016 codec->num_pcms++; 2017 info++; 2018 info->name = "STAC92xx Analog Alt"; 2019 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_analog_alt_playback; 2020 } 2021 2022 if (spec->multiout.dig_out_nid || spec->dig_in_nid) { 2023 codec->num_pcms++; 2024 info++; 2025 info->name = "STAC92xx Digital"; 2026 info->pcm_type = HDA_PCM_TYPE_SPDIF; 2027 if (spec->multiout.dig_out_nid) { 2028 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = stac92xx_pcm_digital_playback; 2029 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid; 2030 } 2031 if (spec->dig_in_nid) { 2032 info->stream[SNDRV_PCM_STREAM_CAPTURE] = stac92xx_pcm_digital_capture; 2033 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid; 2034 } 2035 } 2036 2037 return 0; 2038 } 2039 2040 static unsigned int stac92xx_get_vref(struct hda_codec *codec, hda_nid_t nid) 2041 { 2042 unsigned int pincap = snd_hda_param_read(codec, nid, 2043 AC_PAR_PIN_CAP); 2044 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT; 2045 if (pincap & AC_PINCAP_VREF_100) 2046 return AC_PINCTL_VREF_100; 2047 if (pincap & AC_PINCAP_VREF_80) 2048 return AC_PINCTL_VREF_80; 2049 if (pincap & AC_PINCAP_VREF_50) 2050 return AC_PINCTL_VREF_50; 2051 if (pincap & AC_PINCAP_VREF_GRD) 2052 return AC_PINCTL_VREF_GRD; 2053 return 0; 2054 } 2055 2056 static void stac92xx_auto_set_pinctl(struct hda_codec *codec, hda_nid_t nid, int pin_type) 2057 2058 { 2059 snd_hda_codec_write_cache(codec, nid, 0, 2060 AC_VERB_SET_PIN_WIDGET_CONTROL, pin_type); 2061 } 2062 2063 #define stac92xx_hp_switch_info snd_ctl_boolean_mono_info 2064 2065 static int stac92xx_hp_switch_get(struct snd_kcontrol *kcontrol, 2066 struct snd_ctl_elem_value *ucontrol) 2067 { 2068 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2069 struct sigmatel_spec *spec = codec->spec; 2070 2071 ucontrol->value.integer.value[0] = spec->hp_switch; 2072 return 0; 2073 } 2074 2075 static int stac92xx_hp_switch_put(struct snd_kcontrol *kcontrol, 2076 struct snd_ctl_elem_value *ucontrol) 2077 { 2078 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2079 struct sigmatel_spec *spec = codec->spec; 2080 2081 spec->hp_switch = ucontrol->value.integer.value[0]; 2082 2083 /* check to be sure that the ports are upto date with 2084 * switch changes 2085 */ 2086 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26); 2087 2088 return 1; 2089 } 2090 2091 #define stac92xx_io_switch_info snd_ctl_boolean_mono_info 2092 2093 static int stac92xx_io_switch_get(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2094 { 2095 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2096 struct sigmatel_spec *spec = codec->spec; 2097 int io_idx = kcontrol-> private_value & 0xff; 2098 2099 ucontrol->value.integer.value[0] = spec->io_switch[io_idx]; 2100 return 0; 2101 } 2102 2103 static int stac92xx_io_switch_put(struct snd_kcontrol *kcontrol, struct snd_ctl_elem_value *ucontrol) 2104 { 2105 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2106 struct sigmatel_spec *spec = codec->spec; 2107 hda_nid_t nid = kcontrol->private_value >> 8; 2108 int io_idx = kcontrol-> private_value & 0xff; 2109 unsigned short val = !!ucontrol->value.integer.value[0]; 2110 2111 spec->io_switch[io_idx] = val; 2112 2113 if (val) 2114 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 2115 else { 2116 unsigned int pinctl = AC_PINCTL_IN_EN; 2117 if (io_idx) /* set VREF for mic */ 2118 pinctl |= stac92xx_get_vref(codec, nid); 2119 stac92xx_auto_set_pinctl(codec, nid, pinctl); 2120 } 2121 2122 /* check the auto-mute again: we need to mute/unmute the speaker 2123 * appropriately according to the pin direction 2124 */ 2125 if (spec->hp_detect) 2126 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26); 2127 2128 return 1; 2129 } 2130 2131 #define stac92xx_clfe_switch_info snd_ctl_boolean_mono_info 2132 2133 static int stac92xx_clfe_switch_get(struct snd_kcontrol *kcontrol, 2134 struct snd_ctl_elem_value *ucontrol) 2135 { 2136 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2137 struct sigmatel_spec *spec = codec->spec; 2138 2139 ucontrol->value.integer.value[0] = spec->clfe_swap; 2140 return 0; 2141 } 2142 2143 static int stac92xx_clfe_switch_put(struct snd_kcontrol *kcontrol, 2144 struct snd_ctl_elem_value *ucontrol) 2145 { 2146 struct hda_codec *codec = snd_kcontrol_chip(kcontrol); 2147 struct sigmatel_spec *spec = codec->spec; 2148 hda_nid_t nid = kcontrol->private_value & 0xff; 2149 unsigned int val = !!ucontrol->value.integer.value[0]; 2150 2151 if (spec->clfe_swap == val) 2152 return 0; 2153 2154 spec->clfe_swap = val; 2155 2156 snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE, 2157 spec->clfe_swap ? 0x4 : 0x0); 2158 2159 return 1; 2160 } 2161 2162 #define STAC_CODEC_HP_SWITCH(xname) \ 2163 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2164 .name = xname, \ 2165 .index = 0, \ 2166 .info = stac92xx_hp_switch_info, \ 2167 .get = stac92xx_hp_switch_get, \ 2168 .put = stac92xx_hp_switch_put, \ 2169 } 2170 2171 #define STAC_CODEC_IO_SWITCH(xname, xpval) \ 2172 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2173 .name = xname, \ 2174 .index = 0, \ 2175 .info = stac92xx_io_switch_info, \ 2176 .get = stac92xx_io_switch_get, \ 2177 .put = stac92xx_io_switch_put, \ 2178 .private_value = xpval, \ 2179 } 2180 2181 #define STAC_CODEC_CLFE_SWITCH(xname, xpval) \ 2182 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \ 2183 .name = xname, \ 2184 .index = 0, \ 2185 .info = stac92xx_clfe_switch_info, \ 2186 .get = stac92xx_clfe_switch_get, \ 2187 .put = stac92xx_clfe_switch_put, \ 2188 .private_value = xpval, \ 2189 } 2190 2191 enum { 2192 STAC_CTL_WIDGET_VOL, 2193 STAC_CTL_WIDGET_MUTE, 2194 STAC_CTL_WIDGET_MONO_MUX, 2195 STAC_CTL_WIDGET_HP_SWITCH, 2196 STAC_CTL_WIDGET_IO_SWITCH, 2197 STAC_CTL_WIDGET_CLFE_SWITCH 2198 }; 2199 2200 static struct snd_kcontrol_new stac92xx_control_templates[] = { 2201 HDA_CODEC_VOLUME(NULL, 0, 0, 0), 2202 HDA_CODEC_MUTE(NULL, 0, 0, 0), 2203 STAC_MONO_MUX, 2204 STAC_CODEC_HP_SWITCH(NULL), 2205 STAC_CODEC_IO_SWITCH(NULL, 0), 2206 STAC_CODEC_CLFE_SWITCH(NULL, 0), 2207 }; 2208 2209 /* add dynamic controls */ 2210 static int stac92xx_add_control(struct sigmatel_spec *spec, int type, const char *name, unsigned long val) 2211 { 2212 struct snd_kcontrol_new *knew; 2213 2214 if (spec->num_kctl_used >= spec->num_kctl_alloc) { 2215 int num = spec->num_kctl_alloc + NUM_CONTROL_ALLOC; 2216 2217 knew = kcalloc(num + 1, sizeof(*knew), GFP_KERNEL); /* array + terminator */ 2218 if (! knew) 2219 return -ENOMEM; 2220 if (spec->kctl_alloc) { 2221 memcpy(knew, spec->kctl_alloc, sizeof(*knew) * spec->num_kctl_alloc); 2222 kfree(spec->kctl_alloc); 2223 } 2224 spec->kctl_alloc = knew; 2225 spec->num_kctl_alloc = num; 2226 } 2227 2228 knew = &spec->kctl_alloc[spec->num_kctl_used]; 2229 *knew = stac92xx_control_templates[type]; 2230 knew->name = kstrdup(name, GFP_KERNEL); 2231 if (! knew->name) 2232 return -ENOMEM; 2233 knew->private_value = val; 2234 spec->num_kctl_used++; 2235 return 0; 2236 } 2237 2238 /* flag inputs as additional dynamic lineouts */ 2239 static int stac92xx_add_dyn_out_pins(struct hda_codec *codec, struct auto_pin_cfg *cfg) 2240 { 2241 struct sigmatel_spec *spec = codec->spec; 2242 unsigned int wcaps, wtype; 2243 int i, num_dacs = 0; 2244 2245 /* use the wcaps cache to count all DACs available for line-outs */ 2246 for (i = 0; i < codec->num_nodes; i++) { 2247 wcaps = codec->wcaps[i]; 2248 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 2249 2250 if (wtype == AC_WID_AUD_OUT && !(wcaps & AC_WCAP_DIGITAL)) 2251 num_dacs++; 2252 } 2253 2254 snd_printdd("%s: total dac count=%d\n", __func__, num_dacs); 2255 2256 switch (cfg->line_outs) { 2257 case 3: 2258 /* add line-in as side */ 2259 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 3) { 2260 cfg->line_out_pins[cfg->line_outs] = 2261 cfg->input_pins[AUTO_PIN_LINE]; 2262 spec->line_switch = 1; 2263 cfg->line_outs++; 2264 } 2265 break; 2266 case 2: 2267 /* add line-in as clfe and mic as side */ 2268 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 2) { 2269 cfg->line_out_pins[cfg->line_outs] = 2270 cfg->input_pins[AUTO_PIN_LINE]; 2271 spec->line_switch = 1; 2272 cfg->line_outs++; 2273 } 2274 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 3) { 2275 cfg->line_out_pins[cfg->line_outs] = 2276 cfg->input_pins[AUTO_PIN_MIC]; 2277 spec->mic_switch = 1; 2278 cfg->line_outs++; 2279 } 2280 break; 2281 case 1: 2282 /* add line-in as surr and mic as clfe */ 2283 if (cfg->input_pins[AUTO_PIN_LINE] && num_dacs > 1) { 2284 cfg->line_out_pins[cfg->line_outs] = 2285 cfg->input_pins[AUTO_PIN_LINE]; 2286 spec->line_switch = 1; 2287 cfg->line_outs++; 2288 } 2289 if (cfg->input_pins[AUTO_PIN_MIC] && num_dacs > 2) { 2290 cfg->line_out_pins[cfg->line_outs] = 2291 cfg->input_pins[AUTO_PIN_MIC]; 2292 spec->mic_switch = 1; 2293 cfg->line_outs++; 2294 } 2295 break; 2296 } 2297 2298 return 0; 2299 } 2300 2301 2302 static int is_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2303 { 2304 int i; 2305 2306 for (i = 0; i < spec->multiout.num_dacs; i++) { 2307 if (spec->multiout.dac_nids[i] == nid) 2308 return 1; 2309 } 2310 2311 return 0; 2312 } 2313 2314 /* 2315 * Fill in the dac_nids table from the parsed pin configuration 2316 * This function only works when every pin in line_out_pins[] 2317 * contains atleast one DAC in its connection list. Some 92xx 2318 * codecs are not connected directly to a DAC, such as the 9200 2319 * and 9202/925x. For those, dac_nids[] must be hard-coded. 2320 */ 2321 static int stac92xx_auto_fill_dac_nids(struct hda_codec *codec, 2322 struct auto_pin_cfg *cfg) 2323 { 2324 struct sigmatel_spec *spec = codec->spec; 2325 int i, j, conn_len = 0; 2326 hda_nid_t nid, conn[HDA_MAX_CONNECTIONS]; 2327 unsigned int wcaps, wtype; 2328 2329 for (i = 0; i < cfg->line_outs; i++) { 2330 nid = cfg->line_out_pins[i]; 2331 conn_len = snd_hda_get_connections(codec, nid, conn, 2332 HDA_MAX_CONNECTIONS); 2333 for (j = 0; j < conn_len; j++) { 2334 wcaps = snd_hda_param_read(codec, conn[j], 2335 AC_PAR_AUDIO_WIDGET_CAP); 2336 wtype = (wcaps & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT; 2337 if (wtype != AC_WID_AUD_OUT || 2338 (wcaps & AC_WCAP_DIGITAL)) 2339 continue; 2340 /* conn[j] is a DAC routed to this line-out */ 2341 if (!is_in_dac_nids(spec, conn[j])) 2342 break; 2343 } 2344 2345 if (j == conn_len) { 2346 if (spec->multiout.num_dacs > 0) { 2347 /* we have already working output pins, 2348 * so let's drop the broken ones again 2349 */ 2350 cfg->line_outs = spec->multiout.num_dacs; 2351 break; 2352 } 2353 /* error out, no available DAC found */ 2354 snd_printk(KERN_ERR 2355 "%s: No available DAC for pin 0x%x\n", 2356 __func__, nid); 2357 return -ENODEV; 2358 } 2359 2360 spec->multiout.dac_nids[i] = conn[j]; 2361 spec->multiout.num_dacs++; 2362 if (conn_len > 1) { 2363 /* select this DAC in the pin's input mux */ 2364 snd_hda_codec_write_cache(codec, nid, 0, 2365 AC_VERB_SET_CONNECT_SEL, j); 2366 2367 } 2368 } 2369 2370 snd_printd("dac_nids=%d (0x%x/0x%x/0x%x/0x%x/0x%x)\n", 2371 spec->multiout.num_dacs, 2372 spec->multiout.dac_nids[0], 2373 spec->multiout.dac_nids[1], 2374 spec->multiout.dac_nids[2], 2375 spec->multiout.dac_nids[3], 2376 spec->multiout.dac_nids[4]); 2377 return 0; 2378 } 2379 2380 /* create volume control/switch for the given prefx type */ 2381 static int create_controls(struct sigmatel_spec *spec, const char *pfx, hda_nid_t nid, int chs) 2382 { 2383 char name[32]; 2384 int err; 2385 2386 sprintf(name, "%s Playback Volume", pfx); 2387 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, name, 2388 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 2389 if (err < 0) 2390 return err; 2391 sprintf(name, "%s Playback Switch", pfx); 2392 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, name, 2393 HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT)); 2394 if (err < 0) 2395 return err; 2396 return 0; 2397 } 2398 2399 static int add_spec_dacs(struct sigmatel_spec *spec, hda_nid_t nid) 2400 { 2401 if (!spec->multiout.hp_nid) 2402 spec->multiout.hp_nid = nid; 2403 else if (spec->multiout.num_dacs > 4) { 2404 printk(KERN_WARNING "stac92xx: No space for DAC 0x%x\n", nid); 2405 return 1; 2406 } else { 2407 spec->multiout.dac_nids[spec->multiout.num_dacs] = nid; 2408 spec->multiout.num_dacs++; 2409 } 2410 return 0; 2411 } 2412 2413 static int check_in_dac_nids(struct sigmatel_spec *spec, hda_nid_t nid) 2414 { 2415 if (is_in_dac_nids(spec, nid)) 2416 return 1; 2417 if (spec->multiout.hp_nid == nid) 2418 return 1; 2419 return 0; 2420 } 2421 2422 /* add playback controls from the parsed DAC table */ 2423 static int stac92xx_auto_create_multi_out_ctls(struct hda_codec *codec, 2424 const struct auto_pin_cfg *cfg) 2425 { 2426 static const char *chname[4] = { 2427 "Front", "Surround", NULL /*CLFE*/, "Side" 2428 }; 2429 hda_nid_t nid; 2430 int i, err; 2431 2432 struct sigmatel_spec *spec = codec->spec; 2433 unsigned int wid_caps, pincap; 2434 2435 2436 for (i = 0; i < cfg->line_outs && i < spec->multiout.num_dacs; i++) { 2437 if (!spec->multiout.dac_nids[i]) 2438 continue; 2439 2440 nid = spec->multiout.dac_nids[i]; 2441 2442 if (i == 2) { 2443 /* Center/LFE */ 2444 err = create_controls(spec, "Center", nid, 1); 2445 if (err < 0) 2446 return err; 2447 err = create_controls(spec, "LFE", nid, 2); 2448 if (err < 0) 2449 return err; 2450 2451 wid_caps = get_wcaps(codec, nid); 2452 2453 if (wid_caps & AC_WCAP_LR_SWAP) { 2454 err = stac92xx_add_control(spec, 2455 STAC_CTL_WIDGET_CLFE_SWITCH, 2456 "Swap Center/LFE Playback Switch", nid); 2457 2458 if (err < 0) 2459 return err; 2460 } 2461 2462 } else { 2463 err = create_controls(spec, chname[i], nid, 3); 2464 if (err < 0) 2465 return err; 2466 } 2467 } 2468 2469 if (cfg->hp_outs > 1) { 2470 err = stac92xx_add_control(spec, 2471 STAC_CTL_WIDGET_HP_SWITCH, 2472 "Headphone as Line Out Switch", 0); 2473 if (err < 0) 2474 return err; 2475 } 2476 2477 if (spec->line_switch) { 2478 nid = cfg->input_pins[AUTO_PIN_LINE]; 2479 pincap = snd_hda_param_read(codec, nid, 2480 AC_PAR_PIN_CAP); 2481 if (pincap & AC_PINCAP_OUT) { 2482 err = stac92xx_add_control(spec, 2483 STAC_CTL_WIDGET_IO_SWITCH, 2484 "Line In as Output Switch", nid << 8); 2485 if (err < 0) 2486 return err; 2487 } 2488 } 2489 2490 if (spec->mic_switch) { 2491 unsigned int def_conf; 2492 unsigned int mic_pin = AUTO_PIN_MIC; 2493 again: 2494 nid = cfg->input_pins[mic_pin]; 2495 def_conf = snd_hda_codec_read(codec, nid, 0, 2496 AC_VERB_GET_CONFIG_DEFAULT, 0); 2497 /* some laptops have an internal analog microphone 2498 * which can't be used as a output */ 2499 if (get_defcfg_connect(def_conf) != AC_JACK_PORT_FIXED) { 2500 pincap = snd_hda_param_read(codec, nid, 2501 AC_PAR_PIN_CAP); 2502 if (pincap & AC_PINCAP_OUT) { 2503 err = stac92xx_add_control(spec, 2504 STAC_CTL_WIDGET_IO_SWITCH, 2505 "Mic as Output Switch", (nid << 8) | 1); 2506 nid = snd_hda_codec_read(codec, nid, 0, 2507 AC_VERB_GET_CONNECT_LIST, 0) & 0xff; 2508 if (!check_in_dac_nids(spec, nid)) 2509 add_spec_dacs(spec, nid); 2510 if (err < 0) 2511 return err; 2512 } 2513 } else if (mic_pin == AUTO_PIN_MIC) { 2514 mic_pin = AUTO_PIN_FRONT_MIC; 2515 goto again; 2516 } 2517 } 2518 2519 return 0; 2520 } 2521 2522 /* add playback controls for Speaker and HP outputs */ 2523 static int stac92xx_auto_create_hp_ctls(struct hda_codec *codec, 2524 struct auto_pin_cfg *cfg) 2525 { 2526 struct sigmatel_spec *spec = codec->spec; 2527 hda_nid_t nid; 2528 int i, old_num_dacs, err; 2529 2530 old_num_dacs = spec->multiout.num_dacs; 2531 for (i = 0; i < cfg->hp_outs; i++) { 2532 unsigned int wid_caps = get_wcaps(codec, cfg->hp_pins[i]); 2533 if (wid_caps & AC_WCAP_UNSOL_CAP) 2534 spec->hp_detect = 1; 2535 nid = snd_hda_codec_read(codec, cfg->hp_pins[i], 0, 2536 AC_VERB_GET_CONNECT_LIST, 0) & 0xff; 2537 if (check_in_dac_nids(spec, nid)) 2538 nid = 0; 2539 if (! nid) 2540 continue; 2541 add_spec_dacs(spec, nid); 2542 } 2543 for (i = 0; i < cfg->speaker_outs; i++) { 2544 nid = snd_hda_codec_read(codec, cfg->speaker_pins[i], 0, 2545 AC_VERB_GET_CONNECT_LIST, 0) & 0xff; 2546 if (check_in_dac_nids(spec, nid)) 2547 nid = 0; 2548 if (! nid) 2549 continue; 2550 add_spec_dacs(spec, nid); 2551 } 2552 for (i = 0; i < cfg->line_outs; i++) { 2553 nid = snd_hda_codec_read(codec, cfg->line_out_pins[i], 0, 2554 AC_VERB_GET_CONNECT_LIST, 0) & 0xff; 2555 if (check_in_dac_nids(spec, nid)) 2556 nid = 0; 2557 if (! nid) 2558 continue; 2559 add_spec_dacs(spec, nid); 2560 } 2561 for (i = old_num_dacs; i < spec->multiout.num_dacs; i++) { 2562 static const char *pfxs[] = { 2563 "Speaker", "External Speaker", "Speaker2", 2564 }; 2565 err = create_controls(spec, pfxs[i - old_num_dacs], 2566 spec->multiout.dac_nids[i], 3); 2567 if (err < 0) 2568 return err; 2569 } 2570 if (spec->multiout.hp_nid) { 2571 err = create_controls(spec, "Headphone", 2572 spec->multiout.hp_nid, 3); 2573 if (err < 0) 2574 return err; 2575 } 2576 2577 return 0; 2578 } 2579 2580 /* labels for mono mux outputs */ 2581 static const char *stac92xx_mono_labels[3] = { 2582 "DAC0", "DAC1", "Mixer" 2583 }; 2584 2585 /* create mono mux for mono out on capable codecs */ 2586 static int stac92xx_auto_create_mono_output_ctls(struct hda_codec *codec) 2587 { 2588 struct sigmatel_spec *spec = codec->spec; 2589 struct hda_input_mux *mono_mux = &spec->private_mono_mux; 2590 int i, num_cons; 2591 hda_nid_t con_lst[ARRAY_SIZE(stac92xx_mono_labels)]; 2592 2593 num_cons = snd_hda_get_connections(codec, 2594 spec->mono_nid, 2595 con_lst, 2596 HDA_MAX_NUM_INPUTS); 2597 if (!num_cons || num_cons > ARRAY_SIZE(stac92xx_mono_labels)) 2598 return -EINVAL; 2599 2600 for (i = 0; i < num_cons; i++) { 2601 mono_mux->items[mono_mux->num_items].label = 2602 stac92xx_mono_labels[i]; 2603 mono_mux->items[mono_mux->num_items].index = i; 2604 mono_mux->num_items++; 2605 } 2606 2607 return stac92xx_add_control(spec, STAC_CTL_WIDGET_MONO_MUX, 2608 "Mono Mux", spec->mono_nid); 2609 } 2610 2611 /* labels for dmic mux inputs */ 2612 static const char *stac92xx_dmic_labels[5] = { 2613 "Analog Inputs", "Digital Mic 1", "Digital Mic 2", 2614 "Digital Mic 3", "Digital Mic 4" 2615 }; 2616 2617 /* create playback/capture controls for input pins on dmic capable codecs */ 2618 static int stac92xx_auto_create_dmic_input_ctls(struct hda_codec *codec, 2619 const struct auto_pin_cfg *cfg) 2620 { 2621 struct sigmatel_spec *spec = codec->spec; 2622 struct hda_input_mux *dimux = &spec->private_dimux; 2623 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; 2624 int err, i, j; 2625 char name[32]; 2626 2627 dimux->items[dimux->num_items].label = stac92xx_dmic_labels[0]; 2628 dimux->items[dimux->num_items].index = 0; 2629 dimux->num_items++; 2630 2631 for (i = 0; i < spec->num_dmics; i++) { 2632 hda_nid_t nid; 2633 int index; 2634 int num_cons; 2635 unsigned int wcaps; 2636 unsigned int def_conf; 2637 2638 def_conf = snd_hda_codec_read(codec, 2639 spec->dmic_nids[i], 2640 0, 2641 AC_VERB_GET_CONFIG_DEFAULT, 2642 0); 2643 if (get_defcfg_connect(def_conf) == AC_JACK_PORT_NONE) 2644 continue; 2645 2646 nid = spec->dmic_nids[i]; 2647 num_cons = snd_hda_get_connections(codec, 2648 spec->dmux_nids[0], 2649 con_lst, 2650 HDA_MAX_NUM_INPUTS); 2651 for (j = 0; j < num_cons; j++) 2652 if (con_lst[j] == nid) { 2653 index = j; 2654 goto found; 2655 } 2656 continue; 2657 found: 2658 wcaps = get_wcaps(codec, nid); 2659 2660 if (wcaps & AC_WCAP_OUT_AMP) { 2661 sprintf(name, "%s Capture Volume", 2662 stac92xx_dmic_labels[dimux->num_items]); 2663 2664 err = stac92xx_add_control(spec, 2665 STAC_CTL_WIDGET_VOL, 2666 name, 2667 HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT)); 2668 if (err < 0) 2669 return err; 2670 } 2671 2672 dimux->items[dimux->num_items].label = 2673 stac92xx_dmic_labels[dimux->num_items]; 2674 dimux->items[dimux->num_items].index = index; 2675 dimux->num_items++; 2676 } 2677 2678 return 0; 2679 } 2680 2681 /* create playback/capture controls for input pins */ 2682 static int stac92xx_auto_create_analog_input_ctls(struct hda_codec *codec, const struct auto_pin_cfg *cfg) 2683 { 2684 struct sigmatel_spec *spec = codec->spec; 2685 struct hda_input_mux *imux = &spec->private_imux; 2686 hda_nid_t con_lst[HDA_MAX_NUM_INPUTS]; 2687 int i, j, k; 2688 2689 for (i = 0; i < AUTO_PIN_LAST; i++) { 2690 int index; 2691 2692 if (!cfg->input_pins[i]) 2693 continue; 2694 index = -1; 2695 for (j = 0; j < spec->num_muxes; j++) { 2696 int num_cons; 2697 num_cons = snd_hda_get_connections(codec, 2698 spec->mux_nids[j], 2699 con_lst, 2700 HDA_MAX_NUM_INPUTS); 2701 for (k = 0; k < num_cons; k++) 2702 if (con_lst[k] == cfg->input_pins[i]) { 2703 index = k; 2704 goto found; 2705 } 2706 } 2707 continue; 2708 found: 2709 imux->items[imux->num_items].label = auto_pin_cfg_labels[i]; 2710 imux->items[imux->num_items].index = index; 2711 imux->num_items++; 2712 } 2713 2714 if (imux->num_items) { 2715 /* 2716 * Set the current input for the muxes. 2717 * The STAC9221 has two input muxes with identical source 2718 * NID lists. Hopefully this won't get confused. 2719 */ 2720 for (i = 0; i < spec->num_muxes; i++) { 2721 snd_hda_codec_write_cache(codec, spec->mux_nids[i], 0, 2722 AC_VERB_SET_CONNECT_SEL, 2723 imux->items[0].index); 2724 } 2725 } 2726 2727 return 0; 2728 } 2729 2730 static void stac92xx_auto_init_multi_out(struct hda_codec *codec) 2731 { 2732 struct sigmatel_spec *spec = codec->spec; 2733 int i; 2734 2735 for (i = 0; i < spec->autocfg.line_outs; i++) { 2736 hda_nid_t nid = spec->autocfg.line_out_pins[i]; 2737 stac92xx_auto_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 2738 } 2739 } 2740 2741 static void stac92xx_auto_init_hp_out(struct hda_codec *codec) 2742 { 2743 struct sigmatel_spec *spec = codec->spec; 2744 int i; 2745 2746 for (i = 0; i < spec->autocfg.hp_outs; i++) { 2747 hda_nid_t pin; 2748 pin = spec->autocfg.hp_pins[i]; 2749 if (pin) /* connect to front */ 2750 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN); 2751 } 2752 for (i = 0; i < spec->autocfg.speaker_outs; i++) { 2753 hda_nid_t pin; 2754 pin = spec->autocfg.speaker_pins[i]; 2755 if (pin) /* connect to front */ 2756 stac92xx_auto_set_pinctl(codec, pin, AC_PINCTL_OUT_EN); 2757 } 2758 } 2759 2760 static int stac92xx_parse_auto_config(struct hda_codec *codec, hda_nid_t dig_out, hda_nid_t dig_in) 2761 { 2762 struct sigmatel_spec *spec = codec->spec; 2763 int err; 2764 int hp_speaker_swap = 0; 2765 2766 if ((err = snd_hda_parse_pin_def_config(codec, 2767 &spec->autocfg, 2768 spec->dmic_nids)) < 0) 2769 return err; 2770 if (! spec->autocfg.line_outs) 2771 return 0; /* can't find valid pin config */ 2772 2773 /* If we have no real line-out pin and multiple hp-outs, HPs should 2774 * be set up as multi-channel outputs. 2775 */ 2776 if (spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT && 2777 spec->autocfg.hp_outs > 1) { 2778 /* Copy hp_outs to line_outs, backup line_outs in 2779 * speaker_outs so that the following routines can handle 2780 * HP pins as primary outputs. 2781 */ 2782 memcpy(spec->autocfg.speaker_pins, spec->autocfg.line_out_pins, 2783 sizeof(spec->autocfg.line_out_pins)); 2784 spec->autocfg.speaker_outs = spec->autocfg.line_outs; 2785 memcpy(spec->autocfg.line_out_pins, spec->autocfg.hp_pins, 2786 sizeof(spec->autocfg.hp_pins)); 2787 spec->autocfg.line_outs = spec->autocfg.hp_outs; 2788 hp_speaker_swap = 1; 2789 } 2790 if (spec->autocfg.mono_out_pin) { 2791 int dir = (get_wcaps(codec, spec->autocfg.mono_out_pin) 2792 & AC_WCAP_OUT_AMP) ? HDA_OUTPUT : HDA_INPUT; 2793 u32 caps = query_amp_caps(codec, 2794 spec->autocfg.mono_out_pin, dir); 2795 hda_nid_t conn_list[1]; 2796 2797 /* get the mixer node and then the mono mux if it exists */ 2798 if (snd_hda_get_connections(codec, 2799 spec->autocfg.mono_out_pin, conn_list, 1) && 2800 snd_hda_get_connections(codec, conn_list[0], 2801 conn_list, 1)) { 2802 2803 int wcaps = get_wcaps(codec, conn_list[0]); 2804 int wid_type = (wcaps & AC_WCAP_TYPE) 2805 >> AC_WCAP_TYPE_SHIFT; 2806 /* LR swap check, some stac925x have a mux that 2807 * changes the DACs output path instead of the 2808 * mono-mux path. 2809 */ 2810 if (wid_type == AC_WID_AUD_SEL && 2811 !(wcaps & AC_WCAP_LR_SWAP)) 2812 spec->mono_nid = conn_list[0]; 2813 } 2814 /* all mono outs have a least a mute/unmute switch */ 2815 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_MUTE, 2816 "Mono Playback Switch", 2817 HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin, 2818 1, 0, dir)); 2819 if (err < 0) 2820 return err; 2821 /* check to see if there is volume support for the amp */ 2822 if ((caps & AC_AMPCAP_NUM_STEPS) >> AC_AMPCAP_NUM_STEPS_SHIFT) { 2823 err = stac92xx_add_control(spec, STAC_CTL_WIDGET_VOL, 2824 "Mono Playback Volume", 2825 HDA_COMPOSE_AMP_VAL(spec->autocfg.mono_out_pin, 2826 1, 0, dir)); 2827 if (err < 0) 2828 return err; 2829 } 2830 2831 stac92xx_auto_set_pinctl(codec, spec->autocfg.mono_out_pin, 2832 AC_PINCTL_OUT_EN); 2833 } 2834 2835 if ((err = stac92xx_add_dyn_out_pins(codec, &spec->autocfg)) < 0) 2836 return err; 2837 if (spec->multiout.num_dacs == 0) 2838 if ((err = stac92xx_auto_fill_dac_nids(codec, &spec->autocfg)) < 0) 2839 return err; 2840 2841 err = stac92xx_auto_create_multi_out_ctls(codec, &spec->autocfg); 2842 2843 if (err < 0) 2844 return err; 2845 2846 if (hp_speaker_swap == 1) { 2847 /* Restore the hp_outs and line_outs */ 2848 memcpy(spec->autocfg.hp_pins, spec->autocfg.line_out_pins, 2849 sizeof(spec->autocfg.line_out_pins)); 2850 spec->autocfg.hp_outs = spec->autocfg.line_outs; 2851 memcpy(spec->autocfg.line_out_pins, spec->autocfg.speaker_pins, 2852 sizeof(spec->autocfg.speaker_pins)); 2853 spec->autocfg.line_outs = spec->autocfg.speaker_outs; 2854 memset(spec->autocfg.speaker_pins, 0, 2855 sizeof(spec->autocfg.speaker_pins)); 2856 spec->autocfg.speaker_outs = 0; 2857 } 2858 2859 err = stac92xx_auto_create_hp_ctls(codec, &spec->autocfg); 2860 2861 if (err < 0) 2862 return err; 2863 2864 err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg); 2865 2866 if (err < 0) 2867 return err; 2868 2869 if (spec->mono_nid > 0) { 2870 err = stac92xx_auto_create_mono_output_ctls(codec); 2871 if (err < 0) 2872 return err; 2873 } 2874 2875 if (spec->num_dmics > 0) 2876 if ((err = stac92xx_auto_create_dmic_input_ctls(codec, 2877 &spec->autocfg)) < 0) 2878 return err; 2879 2880 spec->multiout.max_channels = spec->multiout.num_dacs * 2; 2881 if (spec->multiout.max_channels > 2) 2882 spec->surr_switch = 1; 2883 2884 if (spec->autocfg.dig_out_pin) 2885 spec->multiout.dig_out_nid = dig_out; 2886 if (spec->autocfg.dig_in_pin) 2887 spec->dig_in_nid = dig_in; 2888 2889 if (spec->kctl_alloc) 2890 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 2891 2892 spec->input_mux = &spec->private_imux; 2893 if (!spec->dinput_mux) 2894 spec->dinput_mux = &spec->private_dimux; 2895 spec->mono_mux = &spec->private_mono_mux; 2896 2897 return 1; 2898 } 2899 2900 /* add playback controls for HP output */ 2901 static int stac9200_auto_create_hp_ctls(struct hda_codec *codec, 2902 struct auto_pin_cfg *cfg) 2903 { 2904 struct sigmatel_spec *spec = codec->spec; 2905 hda_nid_t pin = cfg->hp_pins[0]; 2906 unsigned int wid_caps; 2907 2908 if (! pin) 2909 return 0; 2910 2911 wid_caps = get_wcaps(codec, pin); 2912 if (wid_caps & AC_WCAP_UNSOL_CAP) 2913 spec->hp_detect = 1; 2914 2915 return 0; 2916 } 2917 2918 /* add playback controls for LFE output */ 2919 static int stac9200_auto_create_lfe_ctls(struct hda_codec *codec, 2920 struct auto_pin_cfg *cfg) 2921 { 2922 struct sigmatel_spec *spec = codec->spec; 2923 int err; 2924 hda_nid_t lfe_pin = 0x0; 2925 int i; 2926 2927 /* 2928 * search speaker outs and line outs for a mono speaker pin 2929 * with an amp. If one is found, add LFE controls 2930 * for it. 2931 */ 2932 for (i = 0; i < spec->autocfg.speaker_outs && lfe_pin == 0x0; i++) { 2933 hda_nid_t pin = spec->autocfg.speaker_pins[i]; 2934 unsigned int wcaps = get_wcaps(codec, pin); 2935 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 2936 if (wcaps == AC_WCAP_OUT_AMP) 2937 /* found a mono speaker with an amp, must be lfe */ 2938 lfe_pin = pin; 2939 } 2940 2941 /* if speaker_outs is 0, then speakers may be in line_outs */ 2942 if (lfe_pin == 0 && spec->autocfg.speaker_outs == 0) { 2943 for (i = 0; i < spec->autocfg.line_outs && lfe_pin == 0x0; i++) { 2944 hda_nid_t pin = spec->autocfg.line_out_pins[i]; 2945 unsigned int defcfg; 2946 defcfg = snd_hda_codec_read(codec, pin, 0, 2947 AC_VERB_GET_CONFIG_DEFAULT, 2948 0x00); 2949 if (get_defcfg_device(defcfg) == AC_JACK_SPEAKER) { 2950 unsigned int wcaps = get_wcaps(codec, pin); 2951 wcaps &= (AC_WCAP_STEREO | AC_WCAP_OUT_AMP); 2952 if (wcaps == AC_WCAP_OUT_AMP) 2953 /* found a mono speaker with an amp, 2954 must be lfe */ 2955 lfe_pin = pin; 2956 } 2957 } 2958 } 2959 2960 if (lfe_pin) { 2961 err = create_controls(spec, "LFE", lfe_pin, 1); 2962 if (err < 0) 2963 return err; 2964 } 2965 2966 return 0; 2967 } 2968 2969 static int stac9200_parse_auto_config(struct hda_codec *codec) 2970 { 2971 struct sigmatel_spec *spec = codec->spec; 2972 int err; 2973 2974 if ((err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL)) < 0) 2975 return err; 2976 2977 if ((err = stac92xx_auto_create_analog_input_ctls(codec, &spec->autocfg)) < 0) 2978 return err; 2979 2980 if ((err = stac9200_auto_create_hp_ctls(codec, &spec->autocfg)) < 0) 2981 return err; 2982 2983 if ((err = stac9200_auto_create_lfe_ctls(codec, &spec->autocfg)) < 0) 2984 return err; 2985 2986 if (spec->autocfg.dig_out_pin) 2987 spec->multiout.dig_out_nid = 0x05; 2988 if (spec->autocfg.dig_in_pin) 2989 spec->dig_in_nid = 0x04; 2990 2991 if (spec->kctl_alloc) 2992 spec->mixers[spec->num_mixers++] = spec->kctl_alloc; 2993 2994 spec->input_mux = &spec->private_imux; 2995 spec->dinput_mux = &spec->private_dimux; 2996 2997 return 1; 2998 } 2999 3000 /* 3001 * Early 2006 Intel Macintoshes with STAC9220X5 codecs seem to have a 3002 * funky external mute control using GPIO pins. 3003 */ 3004 3005 static void stac_gpio_set(struct hda_codec *codec, unsigned int mask, 3006 unsigned int dir_mask, unsigned int data) 3007 { 3008 unsigned int gpiostate, gpiomask, gpiodir; 3009 3010 gpiostate = snd_hda_codec_read(codec, codec->afg, 0, 3011 AC_VERB_GET_GPIO_DATA, 0); 3012 gpiostate = (gpiostate & ~dir_mask) | (data & dir_mask); 3013 3014 gpiomask = snd_hda_codec_read(codec, codec->afg, 0, 3015 AC_VERB_GET_GPIO_MASK, 0); 3016 gpiomask |= mask; 3017 3018 gpiodir = snd_hda_codec_read(codec, codec->afg, 0, 3019 AC_VERB_GET_GPIO_DIRECTION, 0); 3020 gpiodir |= dir_mask; 3021 3022 /* Configure GPIOx as CMOS */ 3023 snd_hda_codec_write(codec, codec->afg, 0, 0x7e7, 0); 3024 3025 snd_hda_codec_write(codec, codec->afg, 0, 3026 AC_VERB_SET_GPIO_MASK, gpiomask); 3027 snd_hda_codec_read(codec, codec->afg, 0, 3028 AC_VERB_SET_GPIO_DIRECTION, gpiodir); /* sync */ 3029 3030 msleep(1); 3031 3032 snd_hda_codec_read(codec, codec->afg, 0, 3033 AC_VERB_SET_GPIO_DATA, gpiostate); /* sync */ 3034 } 3035 3036 static void enable_pin_detect(struct hda_codec *codec, hda_nid_t nid, 3037 unsigned int event) 3038 { 3039 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) 3040 snd_hda_codec_write_cache(codec, nid, 0, 3041 AC_VERB_SET_UNSOLICITED_ENABLE, 3042 (AC_USRSP_EN | event)); 3043 } 3044 3045 static int is_nid_hp_pin(struct auto_pin_cfg *cfg, hda_nid_t nid) 3046 { 3047 int i; 3048 for (i = 0; i < cfg->hp_outs; i++) 3049 if (cfg->hp_pins[i] == nid) 3050 return 1; /* nid is a HP-Out */ 3051 3052 return 0; /* nid is not a HP-Out */ 3053 }; 3054 3055 static void stac92xx_power_down(struct hda_codec *codec) 3056 { 3057 struct sigmatel_spec *spec = codec->spec; 3058 3059 /* power down inactive DACs */ 3060 hda_nid_t *dac; 3061 for (dac = spec->dac_list; *dac; dac++) 3062 if (!is_in_dac_nids(spec, *dac) && 3063 spec->multiout.hp_nid != *dac) 3064 snd_hda_codec_write_cache(codec, *dac, 0, 3065 AC_VERB_SET_POWER_STATE, AC_PWRST_D3); 3066 } 3067 3068 static int stac92xx_init(struct hda_codec *codec) 3069 { 3070 struct sigmatel_spec *spec = codec->spec; 3071 struct auto_pin_cfg *cfg = &spec->autocfg; 3072 int i; 3073 3074 snd_hda_sequence_write(codec, spec->init); 3075 3076 /* set up pins */ 3077 if (spec->hp_detect) { 3078 /* Enable unsolicited responses on the HP widget */ 3079 for (i = 0; i < cfg->hp_outs; i++) 3080 enable_pin_detect(codec, cfg->hp_pins[i], 3081 STAC_HP_EVENT); 3082 /* force to enable the first line-out; the others are set up 3083 * in unsol_event 3084 */ 3085 stac92xx_auto_set_pinctl(codec, spec->autocfg.line_out_pins[0], 3086 AC_PINCTL_OUT_EN); 3087 stac92xx_auto_init_hp_out(codec); 3088 /* fake event to set up pins */ 3089 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26); 3090 } else { 3091 stac92xx_auto_init_multi_out(codec); 3092 stac92xx_auto_init_hp_out(codec); 3093 } 3094 for (i = 0; i < AUTO_PIN_LAST; i++) { 3095 hda_nid_t nid = cfg->input_pins[i]; 3096 if (nid) { 3097 unsigned int pinctl = AC_PINCTL_IN_EN; 3098 if (i == AUTO_PIN_MIC || i == AUTO_PIN_FRONT_MIC) 3099 pinctl |= stac92xx_get_vref(codec, nid); 3100 stac92xx_auto_set_pinctl(codec, nid, pinctl); 3101 } 3102 } 3103 for (i = 0; i < spec->num_dmics; i++) 3104 stac92xx_auto_set_pinctl(codec, spec->dmic_nids[i], 3105 AC_PINCTL_IN_EN); 3106 for (i = 0; i < spec->num_pwrs; i++) { 3107 int event = is_nid_hp_pin(cfg, spec->pwr_nids[i]) 3108 ? STAC_HP_EVENT : STAC_PWR_EVENT; 3109 int pinctl = snd_hda_codec_read(codec, spec->pwr_nids[i], 3110 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3111 int def_conf = snd_hda_codec_read(codec, spec->pwr_nids[i], 3112 0, AC_VERB_GET_CONFIG_DEFAULT, 0); 3113 def_conf = get_defcfg_connect(def_conf); 3114 /* outputs are only ports capable of power management 3115 * any attempts on powering down a input port cause the 3116 * referenced VREF to act quirky. 3117 */ 3118 if (pinctl & AC_PINCTL_IN_EN) 3119 continue; 3120 /* skip any ports that don't have jacks since presence 3121 * detection is useless */ 3122 if (def_conf && def_conf != AC_JACK_PORT_FIXED) 3123 continue; 3124 enable_pin_detect(codec, spec->pwr_nids[i], event | i); 3125 codec->patch_ops.unsol_event(codec, (event | i) << 26); 3126 } 3127 if (spec->dac_list) 3128 stac92xx_power_down(codec); 3129 if (cfg->dig_out_pin) 3130 stac92xx_auto_set_pinctl(codec, cfg->dig_out_pin, 3131 AC_PINCTL_OUT_EN); 3132 if (cfg->dig_in_pin) 3133 stac92xx_auto_set_pinctl(codec, cfg->dig_in_pin, 3134 AC_PINCTL_IN_EN); 3135 3136 stac_gpio_set(codec, spec->gpio_mask, 3137 spec->gpio_dir, spec->gpio_data); 3138 3139 return 0; 3140 } 3141 3142 static void stac92xx_free(struct hda_codec *codec) 3143 { 3144 struct sigmatel_spec *spec = codec->spec; 3145 int i; 3146 3147 if (! spec) 3148 return; 3149 3150 if (spec->kctl_alloc) { 3151 for (i = 0; i < spec->num_kctl_used; i++) 3152 kfree(spec->kctl_alloc[i].name); 3153 kfree(spec->kctl_alloc); 3154 } 3155 3156 if (spec->bios_pin_configs) 3157 kfree(spec->bios_pin_configs); 3158 3159 kfree(spec); 3160 } 3161 3162 static void stac92xx_set_pinctl(struct hda_codec *codec, hda_nid_t nid, 3163 unsigned int flag) 3164 { 3165 unsigned int pin_ctl = snd_hda_codec_read(codec, nid, 3166 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 3167 3168 if (pin_ctl & AC_PINCTL_IN_EN) { 3169 /* 3170 * we need to check the current set-up direction of 3171 * shared input pins since they can be switched via 3172 * "xxx as Output" mixer switch 3173 */ 3174 struct sigmatel_spec *spec = codec->spec; 3175 struct auto_pin_cfg *cfg = &spec->autocfg; 3176 if ((nid == cfg->input_pins[AUTO_PIN_LINE] && 3177 spec->line_switch) || 3178 (nid == cfg->input_pins[AUTO_PIN_MIC] && 3179 spec->mic_switch)) 3180 return; 3181 } 3182 3183 /* if setting pin direction bits, clear the current 3184 direction bits first */ 3185 if (flag & (AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN)) 3186 pin_ctl &= ~(AC_PINCTL_IN_EN | AC_PINCTL_OUT_EN); 3187 3188 snd_hda_codec_write_cache(codec, nid, 0, 3189 AC_VERB_SET_PIN_WIDGET_CONTROL, 3190 pin_ctl | flag); 3191 } 3192 3193 static void stac92xx_reset_pinctl(struct hda_codec *codec, hda_nid_t nid, 3194 unsigned int flag) 3195 { 3196 unsigned int pin_ctl = snd_hda_codec_read(codec, nid, 3197 0, AC_VERB_GET_PIN_WIDGET_CONTROL, 0x00); 3198 snd_hda_codec_write_cache(codec, nid, 0, 3199 AC_VERB_SET_PIN_WIDGET_CONTROL, 3200 pin_ctl & ~flag); 3201 } 3202 3203 static int get_hp_pin_presence(struct hda_codec *codec, hda_nid_t nid) 3204 { 3205 if (!nid) 3206 return 0; 3207 if (snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PIN_SENSE, 0x00) 3208 & (1 << 31)) { 3209 unsigned int pinctl; 3210 pinctl = snd_hda_codec_read(codec, nid, 0, 3211 AC_VERB_GET_PIN_WIDGET_CONTROL, 0); 3212 if (pinctl & AC_PINCTL_IN_EN) 3213 return 0; /* mic- or line-input */ 3214 else 3215 return 1; /* HP-output */ 3216 } 3217 return 0; 3218 } 3219 3220 static void stac92xx_hp_detect(struct hda_codec *codec, unsigned int res) 3221 { 3222 struct sigmatel_spec *spec = codec->spec; 3223 struct auto_pin_cfg *cfg = &spec->autocfg; 3224 int nid = cfg->hp_pins[cfg->hp_outs - 1]; 3225 int i, presence; 3226 3227 presence = 0; 3228 if (spec->gpio_mute) 3229 presence = !(snd_hda_codec_read(codec, codec->afg, 0, 3230 AC_VERB_GET_GPIO_DATA, 0) & spec->gpio_mute); 3231 3232 for (i = 0; i < cfg->hp_outs; i++) { 3233 if (presence) 3234 break; 3235 if (spec->hp_switch && cfg->hp_pins[i] == nid) 3236 break; 3237 presence = get_hp_pin_presence(codec, cfg->hp_pins[i]); 3238 } 3239 3240 if (presence) { 3241 /* disable lineouts, enable hp */ 3242 if (spec->hp_switch) 3243 stac92xx_reset_pinctl(codec, nid, AC_PINCTL_OUT_EN); 3244 for (i = 0; i < cfg->line_outs; i++) 3245 stac92xx_reset_pinctl(codec, cfg->line_out_pins[i], 3246 AC_PINCTL_OUT_EN); 3247 for (i = 0; i < cfg->speaker_outs; i++) 3248 stac92xx_reset_pinctl(codec, cfg->speaker_pins[i], 3249 AC_PINCTL_OUT_EN); 3250 if (spec->eapd_mask) 3251 stac_gpio_set(codec, spec->gpio_mask, 3252 spec->gpio_dir, spec->gpio_data & 3253 ~spec->eapd_mask); 3254 } else { 3255 /* enable lineouts, disable hp */ 3256 if (spec->hp_switch) 3257 stac92xx_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 3258 for (i = 0; i < cfg->line_outs; i++) 3259 stac92xx_set_pinctl(codec, cfg->line_out_pins[i], 3260 AC_PINCTL_OUT_EN); 3261 for (i = 0; i < cfg->speaker_outs; i++) 3262 stac92xx_set_pinctl(codec, cfg->speaker_pins[i], 3263 AC_PINCTL_OUT_EN); 3264 if (spec->eapd_mask) 3265 stac_gpio_set(codec, spec->gpio_mask, 3266 spec->gpio_dir, spec->gpio_data | 3267 spec->eapd_mask); 3268 } 3269 if (!spec->hp_switch && cfg->hp_outs > 1 && presence) 3270 stac92xx_set_pinctl(codec, nid, AC_PINCTL_OUT_EN); 3271 } 3272 3273 static void stac92xx_pin_sense(struct hda_codec *codec, int idx) 3274 { 3275 struct sigmatel_spec *spec = codec->spec; 3276 hda_nid_t nid = spec->pwr_nids[idx]; 3277 int presence, val; 3278 val = snd_hda_codec_read(codec, codec->afg, 0, 0x0fec, 0x0) 3279 & 0x000000ff; 3280 presence = get_hp_pin_presence(codec, nid); 3281 idx = 1 << idx; 3282 3283 if (presence) 3284 val &= ~idx; 3285 else 3286 val |= idx; 3287 3288 /* power down unused output ports */ 3289 snd_hda_codec_write(codec, codec->afg, 0, 0x7ec, val); 3290 }; 3291 3292 static void stac92xx_unsol_event(struct hda_codec *codec, unsigned int res) 3293 { 3294 struct sigmatel_spec *spec = codec->spec; 3295 int idx = res >> 26 & 0x0f; 3296 3297 switch ((res >> 26) & 0x30) { 3298 case STAC_HP_EVENT: 3299 stac92xx_hp_detect(codec, res); 3300 /* fallthru */ 3301 case STAC_PWR_EVENT: 3302 if (spec->num_pwrs > 0) 3303 stac92xx_pin_sense(codec, idx); 3304 } 3305 } 3306 3307 #ifdef SND_HDA_NEEDS_RESUME 3308 static int stac92xx_resume(struct hda_codec *codec) 3309 { 3310 struct sigmatel_spec *spec = codec->spec; 3311 3312 stac92xx_set_config_regs(codec); 3313 snd_hda_sequence_write(codec, spec->init); 3314 stac_gpio_set(codec, spec->gpio_mask, 3315 spec->gpio_dir, spec->gpio_data); 3316 snd_hda_codec_resume_amp(codec); 3317 snd_hda_codec_resume_cache(codec); 3318 /* power down inactive DACs */ 3319 if (spec->dac_list) 3320 stac92xx_power_down(codec); 3321 /* invoke unsolicited event to reset the HP state */ 3322 if (spec->hp_detect) 3323 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26); 3324 return 0; 3325 } 3326 #endif 3327 3328 static struct hda_codec_ops stac92xx_patch_ops = { 3329 .build_controls = stac92xx_build_controls, 3330 .build_pcms = stac92xx_build_pcms, 3331 .init = stac92xx_init, 3332 .free = stac92xx_free, 3333 .unsol_event = stac92xx_unsol_event, 3334 #ifdef SND_HDA_NEEDS_RESUME 3335 .resume = stac92xx_resume, 3336 #endif 3337 }; 3338 3339 static int patch_stac9200(struct hda_codec *codec) 3340 { 3341 struct sigmatel_spec *spec; 3342 int err; 3343 3344 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3345 if (spec == NULL) 3346 return -ENOMEM; 3347 3348 codec->spec = spec; 3349 spec->num_pins = ARRAY_SIZE(stac9200_pin_nids); 3350 spec->pin_nids = stac9200_pin_nids; 3351 spec->board_config = snd_hda_check_board_config(codec, STAC_9200_MODELS, 3352 stac9200_models, 3353 stac9200_cfg_tbl); 3354 if (spec->board_config < 0) { 3355 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9200, using BIOS defaults\n"); 3356 err = stac92xx_save_bios_config_regs(codec); 3357 if (err < 0) { 3358 stac92xx_free(codec); 3359 return err; 3360 } 3361 spec->pin_configs = spec->bios_pin_configs; 3362 } else { 3363 spec->pin_configs = stac9200_brd_tbl[spec->board_config]; 3364 stac92xx_set_config_regs(codec); 3365 } 3366 3367 spec->multiout.max_channels = 2; 3368 spec->multiout.num_dacs = 1; 3369 spec->multiout.dac_nids = stac9200_dac_nids; 3370 spec->adc_nids = stac9200_adc_nids; 3371 spec->mux_nids = stac9200_mux_nids; 3372 spec->num_muxes = 1; 3373 spec->num_dmics = 0; 3374 spec->num_adcs = 1; 3375 spec->num_pwrs = 0; 3376 3377 if (spec->board_config == STAC_9200_GATEWAY || 3378 spec->board_config == STAC_9200_OQO) 3379 spec->init = stac9200_eapd_init; 3380 else 3381 spec->init = stac9200_core_init; 3382 spec->mixer = stac9200_mixer; 3383 3384 if (spec->board_config == STAC_9200_PANASONIC) { 3385 spec->gpio_mask = spec->gpio_dir = 0x09; 3386 spec->gpio_data = 0x00; 3387 } 3388 3389 err = stac9200_parse_auto_config(codec); 3390 if (err < 0) { 3391 stac92xx_free(codec); 3392 return err; 3393 } 3394 3395 codec->patch_ops = stac92xx_patch_ops; 3396 3397 return 0; 3398 } 3399 3400 static int patch_stac925x(struct hda_codec *codec) 3401 { 3402 struct sigmatel_spec *spec; 3403 int err; 3404 3405 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3406 if (spec == NULL) 3407 return -ENOMEM; 3408 3409 codec->spec = spec; 3410 spec->num_pins = ARRAY_SIZE(stac925x_pin_nids); 3411 spec->pin_nids = stac925x_pin_nids; 3412 spec->board_config = snd_hda_check_board_config(codec, STAC_925x_MODELS, 3413 stac925x_models, 3414 stac925x_cfg_tbl); 3415 again: 3416 if (spec->board_config < 0) { 3417 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC925x," 3418 "using BIOS defaults\n"); 3419 err = stac92xx_save_bios_config_regs(codec); 3420 if (err < 0) { 3421 stac92xx_free(codec); 3422 return err; 3423 } 3424 spec->pin_configs = spec->bios_pin_configs; 3425 } else if (stac925x_brd_tbl[spec->board_config] != NULL){ 3426 spec->pin_configs = stac925x_brd_tbl[spec->board_config]; 3427 stac92xx_set_config_regs(codec); 3428 } 3429 3430 spec->multiout.max_channels = 2; 3431 spec->multiout.num_dacs = 1; 3432 spec->multiout.dac_nids = stac925x_dac_nids; 3433 spec->adc_nids = stac925x_adc_nids; 3434 spec->mux_nids = stac925x_mux_nids; 3435 spec->num_muxes = 1; 3436 spec->num_adcs = 1; 3437 spec->num_pwrs = 0; 3438 switch (codec->vendor_id) { 3439 case 0x83847632: /* STAC9202 */ 3440 case 0x83847633: /* STAC9202D */ 3441 case 0x83847636: /* STAC9251 */ 3442 case 0x83847637: /* STAC9251D */ 3443 spec->num_dmics = STAC925X_NUM_DMICS; 3444 spec->dmic_nids = stac925x_dmic_nids; 3445 spec->num_dmuxes = ARRAY_SIZE(stac925x_dmux_nids); 3446 spec->dmux_nids = stac925x_dmux_nids; 3447 break; 3448 default: 3449 spec->num_dmics = 0; 3450 break; 3451 } 3452 3453 spec->init = stac925x_core_init; 3454 spec->mixer = stac925x_mixer; 3455 3456 err = stac92xx_parse_auto_config(codec, 0x8, 0x7); 3457 if (!err) { 3458 if (spec->board_config < 0) { 3459 printk(KERN_WARNING "hda_codec: No auto-config is " 3460 "available, default to model=ref\n"); 3461 spec->board_config = STAC_925x_REF; 3462 goto again; 3463 } 3464 err = -EINVAL; 3465 } 3466 if (err < 0) { 3467 stac92xx_free(codec); 3468 return err; 3469 } 3470 3471 codec->patch_ops = stac92xx_patch_ops; 3472 3473 return 0; 3474 } 3475 3476 static struct hda_input_mux stac92hd73xx_dmux = { 3477 .num_items = 4, 3478 .items = { 3479 { "Analog Inputs", 0x0b }, 3480 { "CD", 0x08 }, 3481 { "Digital Mic 1", 0x09 }, 3482 { "Digital Mic 2", 0x0a }, 3483 } 3484 }; 3485 3486 static int patch_stac92hd73xx(struct hda_codec *codec) 3487 { 3488 struct sigmatel_spec *spec; 3489 hda_nid_t conn[STAC92HD73_DAC_COUNT + 2]; 3490 int err = 0; 3491 3492 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3493 if (spec == NULL) 3494 return -ENOMEM; 3495 3496 codec->spec = spec; 3497 spec->num_pins = ARRAY_SIZE(stac92hd73xx_pin_nids); 3498 spec->pin_nids = stac92hd73xx_pin_nids; 3499 spec->board_config = snd_hda_check_board_config(codec, 3500 STAC_92HD73XX_MODELS, 3501 stac92hd73xx_models, 3502 stac92hd73xx_cfg_tbl); 3503 again: 3504 if (spec->board_config < 0) { 3505 snd_printdd(KERN_INFO "hda_codec: Unknown model for" 3506 " STAC92HD73XX, using BIOS defaults\n"); 3507 err = stac92xx_save_bios_config_regs(codec); 3508 if (err < 0) { 3509 stac92xx_free(codec); 3510 return err; 3511 } 3512 spec->pin_configs = spec->bios_pin_configs; 3513 } else { 3514 spec->pin_configs = stac92hd73xx_brd_tbl[spec->board_config]; 3515 stac92xx_set_config_regs(codec); 3516 } 3517 3518 spec->multiout.num_dacs = snd_hda_get_connections(codec, 0x0a, 3519 conn, STAC92HD73_DAC_COUNT + 2) - 1; 3520 3521 if (spec->multiout.num_dacs < 0) { 3522 printk(KERN_WARNING "hda_codec: Could not determine " 3523 "number of channels defaulting to DAC count\n"); 3524 spec->multiout.num_dacs = STAC92HD73_DAC_COUNT; 3525 } 3526 3527 switch (spec->multiout.num_dacs) { 3528 case 0x3: /* 6 Channel */ 3529 spec->multiout.hp_nid = 0x17; 3530 spec->mixer = stac92hd73xx_6ch_mixer; 3531 spec->init = stac92hd73xx_6ch_core_init; 3532 break; 3533 case 0x4: /* 8 Channel */ 3534 spec->multiout.hp_nid = 0x18; 3535 spec->mixer = stac92hd73xx_8ch_mixer; 3536 spec->init = stac92hd73xx_8ch_core_init; 3537 break; 3538 case 0x5: /* 10 Channel */ 3539 spec->multiout.hp_nid = 0x19; 3540 spec->mixer = stac92hd73xx_10ch_mixer; 3541 spec->init = stac92hd73xx_10ch_core_init; 3542 }; 3543 3544 spec->multiout.dac_nids = stac92hd73xx_dac_nids; 3545 spec->aloopback_mask = 0x01; 3546 spec->aloopback_shift = 8; 3547 3548 spec->mux_nids = stac92hd73xx_mux_nids; 3549 spec->adc_nids = stac92hd73xx_adc_nids; 3550 spec->dmic_nids = stac92hd73xx_dmic_nids; 3551 spec->dmux_nids = stac92hd73xx_dmux_nids; 3552 3553 spec->num_muxes = ARRAY_SIZE(stac92hd73xx_mux_nids); 3554 spec->num_adcs = ARRAY_SIZE(stac92hd73xx_adc_nids); 3555 spec->num_dmuxes = ARRAY_SIZE(stac92hd73xx_dmux_nids); 3556 spec->dinput_mux = &stac92hd73xx_dmux; 3557 /* GPIO0 High = Enable EAPD */ 3558 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 3559 spec->gpio_data = 0x01; 3560 3561 switch (spec->board_config) { 3562 case STAC_DELL_M6: 3563 spec->init = dell_eq_core_init; 3564 switch (codec->subsystem_id) { 3565 case 0x1028025e: /* Analog Mics */ 3566 case 0x1028025f: 3567 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170); 3568 spec->num_dmics = 0; 3569 break; 3570 case 0x10280271: /* Digital Mics */ 3571 case 0x10280272: 3572 spec->init = dell_m6_core_init; 3573 /* fall-through */ 3574 case 0x10280254: 3575 case 0x10280255: 3576 stac92xx_set_config_reg(codec, 0x13, 0x90A60160); 3577 spec->num_dmics = 1; 3578 break; 3579 case 0x10280256: /* Both */ 3580 case 0x10280057: 3581 stac92xx_set_config_reg(codec, 0x0b, 0x90A70170); 3582 stac92xx_set_config_reg(codec, 0x13, 0x90A60160); 3583 spec->num_dmics = 1; 3584 break; 3585 } 3586 break; 3587 default: 3588 spec->num_dmics = STAC92HD73XX_NUM_DMICS; 3589 } 3590 3591 spec->num_pwrs = ARRAY_SIZE(stac92hd73xx_pwr_nids); 3592 spec->pwr_nids = stac92hd73xx_pwr_nids; 3593 3594 err = stac92xx_parse_auto_config(codec, 0x22, 0x24); 3595 3596 if (!err) { 3597 if (spec->board_config < 0) { 3598 printk(KERN_WARNING "hda_codec: No auto-config is " 3599 "available, default to model=ref\n"); 3600 spec->board_config = STAC_92HD73XX_REF; 3601 goto again; 3602 } 3603 err = -EINVAL; 3604 } 3605 3606 if (err < 0) { 3607 stac92xx_free(codec); 3608 return err; 3609 } 3610 3611 codec->patch_ops = stac92xx_patch_ops; 3612 3613 return 0; 3614 } 3615 3616 static int patch_stac92hd71bxx(struct hda_codec *codec) 3617 { 3618 struct sigmatel_spec *spec; 3619 int err = 0; 3620 3621 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3622 if (spec == NULL) 3623 return -ENOMEM; 3624 3625 codec->spec = spec; 3626 spec->num_pins = ARRAY_SIZE(stac92hd71bxx_pin_nids); 3627 spec->num_pwrs = ARRAY_SIZE(stac92hd71bxx_pwr_nids); 3628 spec->pin_nids = stac92hd71bxx_pin_nids; 3629 spec->board_config = snd_hda_check_board_config(codec, 3630 STAC_92HD71BXX_MODELS, 3631 stac92hd71bxx_models, 3632 stac92hd71bxx_cfg_tbl); 3633 again: 3634 if (spec->board_config < 0) { 3635 snd_printdd(KERN_INFO "hda_codec: Unknown model for" 3636 " STAC92HD71BXX, using BIOS defaults\n"); 3637 err = stac92xx_save_bios_config_regs(codec); 3638 if (err < 0) { 3639 stac92xx_free(codec); 3640 return err; 3641 } 3642 spec->pin_configs = spec->bios_pin_configs; 3643 } else { 3644 spec->pin_configs = stac92hd71bxx_brd_tbl[spec->board_config]; 3645 stac92xx_set_config_regs(codec); 3646 } 3647 3648 switch (codec->vendor_id) { 3649 case 0x111d76b6: /* 4 Port without Analog Mixer */ 3650 case 0x111d76b7: 3651 case 0x111d76b4: /* 6 Port without Analog Mixer */ 3652 case 0x111d76b5: 3653 spec->mixer = stac92hd71bxx_mixer; 3654 spec->init = stac92hd71bxx_core_init; 3655 break; 3656 case 0x111d7608: /* 5 Port with Analog Mixer */ 3657 /* no output amps */ 3658 spec->num_pwrs = 0; 3659 spec->mixer = stac92hd71bxx_analog_mixer; 3660 3661 /* disable VSW */ 3662 spec->init = &stac92hd71bxx_analog_core_init[HD_DISABLE_PORTF]; 3663 stac92xx_set_config_reg(codec, 0xf, 0x40f000f0); 3664 break; 3665 case 0x111d7603: /* 6 Port with Analog Mixer */ 3666 /* no output amps */ 3667 spec->num_pwrs = 0; 3668 /* fallthru */ 3669 default: 3670 spec->mixer = stac92hd71bxx_analog_mixer; 3671 spec->init = stac92hd71bxx_analog_core_init; 3672 } 3673 3674 spec->aloopback_mask = 0x20; 3675 spec->aloopback_shift = 0; 3676 3677 /* GPIO0 High = EAPD */ 3678 spec->gpio_mask = 0x01; 3679 spec->gpio_dir = 0x01; 3680 spec->gpio_data = 0x01; 3681 3682 spec->mux_nids = stac92hd71bxx_mux_nids; 3683 spec->adc_nids = stac92hd71bxx_adc_nids; 3684 spec->dmic_nids = stac92hd71bxx_dmic_nids; 3685 spec->dmux_nids = stac92hd71bxx_dmux_nids; 3686 spec->pwr_nids = stac92hd71bxx_pwr_nids; 3687 3688 spec->num_muxes = ARRAY_SIZE(stac92hd71bxx_mux_nids); 3689 spec->num_adcs = ARRAY_SIZE(stac92hd71bxx_adc_nids); 3690 spec->num_dmics = STAC92HD71BXX_NUM_DMICS; 3691 spec->num_dmuxes = ARRAY_SIZE(stac92hd71bxx_dmux_nids); 3692 3693 spec->multiout.num_dacs = 1; 3694 spec->multiout.hp_nid = 0x11; 3695 spec->multiout.dac_nids = stac92hd71bxx_dac_nids; 3696 3697 err = stac92xx_parse_auto_config(codec, 0x21, 0x23); 3698 if (!err) { 3699 if (spec->board_config < 0) { 3700 printk(KERN_WARNING "hda_codec: No auto-config is " 3701 "available, default to model=ref\n"); 3702 spec->board_config = STAC_92HD71BXX_REF; 3703 goto again; 3704 } 3705 err = -EINVAL; 3706 } 3707 3708 if (err < 0) { 3709 stac92xx_free(codec); 3710 return err; 3711 } 3712 3713 codec->patch_ops = stac92xx_patch_ops; 3714 3715 return 0; 3716 }; 3717 3718 static int patch_stac922x(struct hda_codec *codec) 3719 { 3720 struct sigmatel_spec *spec; 3721 int err; 3722 3723 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3724 if (spec == NULL) 3725 return -ENOMEM; 3726 3727 codec->spec = spec; 3728 spec->num_pins = ARRAY_SIZE(stac922x_pin_nids); 3729 spec->pin_nids = stac922x_pin_nids; 3730 spec->board_config = snd_hda_check_board_config(codec, STAC_922X_MODELS, 3731 stac922x_models, 3732 stac922x_cfg_tbl); 3733 if (spec->board_config == STAC_INTEL_MAC_AUTO) { 3734 spec->gpio_mask = spec->gpio_dir = 0x03; 3735 spec->gpio_data = 0x03; 3736 /* Intel Macs have all same PCI SSID, so we need to check 3737 * codec SSID to distinguish the exact models 3738 */ 3739 printk(KERN_INFO "hda_codec: STAC922x, Apple subsys_id=%x\n", codec->subsystem_id); 3740 switch (codec->subsystem_id) { 3741 3742 case 0x106b0800: 3743 spec->board_config = STAC_INTEL_MAC_V1; 3744 break; 3745 case 0x106b0600: 3746 case 0x106b0700: 3747 spec->board_config = STAC_INTEL_MAC_V2; 3748 break; 3749 case 0x106b0e00: 3750 case 0x106b0f00: 3751 case 0x106b1600: 3752 case 0x106b1700: 3753 case 0x106b0200: 3754 case 0x106b1e00: 3755 spec->board_config = STAC_INTEL_MAC_V3; 3756 break; 3757 case 0x106b1a00: 3758 case 0x00000100: 3759 spec->board_config = STAC_INTEL_MAC_V4; 3760 break; 3761 case 0x106b0a00: 3762 case 0x106b2200: 3763 spec->board_config = STAC_INTEL_MAC_V5; 3764 break; 3765 default: 3766 spec->board_config = STAC_INTEL_MAC_V3; 3767 break; 3768 } 3769 } 3770 3771 again: 3772 if (spec->board_config < 0) { 3773 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC922x, " 3774 "using BIOS defaults\n"); 3775 err = stac92xx_save_bios_config_regs(codec); 3776 if (err < 0) { 3777 stac92xx_free(codec); 3778 return err; 3779 } 3780 spec->pin_configs = spec->bios_pin_configs; 3781 } else if (stac922x_brd_tbl[spec->board_config] != NULL) { 3782 spec->pin_configs = stac922x_brd_tbl[spec->board_config]; 3783 stac92xx_set_config_regs(codec); 3784 } 3785 3786 spec->adc_nids = stac922x_adc_nids; 3787 spec->mux_nids = stac922x_mux_nids; 3788 spec->num_muxes = ARRAY_SIZE(stac922x_mux_nids); 3789 spec->num_adcs = ARRAY_SIZE(stac922x_adc_nids); 3790 spec->num_dmics = 0; 3791 spec->num_pwrs = 0; 3792 3793 spec->init = stac922x_core_init; 3794 spec->mixer = stac922x_mixer; 3795 3796 spec->multiout.dac_nids = spec->dac_nids; 3797 3798 err = stac92xx_parse_auto_config(codec, 0x08, 0x09); 3799 if (!err) { 3800 if (spec->board_config < 0) { 3801 printk(KERN_WARNING "hda_codec: No auto-config is " 3802 "available, default to model=ref\n"); 3803 spec->board_config = STAC_D945_REF; 3804 goto again; 3805 } 3806 err = -EINVAL; 3807 } 3808 if (err < 0) { 3809 stac92xx_free(codec); 3810 return err; 3811 } 3812 3813 codec->patch_ops = stac92xx_patch_ops; 3814 3815 /* Fix Mux capture level; max to 2 */ 3816 snd_hda_override_amp_caps(codec, 0x12, HDA_OUTPUT, 3817 (0 << AC_AMPCAP_OFFSET_SHIFT) | 3818 (2 << AC_AMPCAP_NUM_STEPS_SHIFT) | 3819 (0x27 << AC_AMPCAP_STEP_SIZE_SHIFT) | 3820 (0 << AC_AMPCAP_MUTE_SHIFT)); 3821 3822 return 0; 3823 } 3824 3825 static int patch_stac927x(struct hda_codec *codec) 3826 { 3827 struct sigmatel_spec *spec; 3828 int err; 3829 3830 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3831 if (spec == NULL) 3832 return -ENOMEM; 3833 3834 codec->spec = spec; 3835 spec->num_pins = ARRAY_SIZE(stac927x_pin_nids); 3836 spec->pin_nids = stac927x_pin_nids; 3837 spec->board_config = snd_hda_check_board_config(codec, STAC_927X_MODELS, 3838 stac927x_models, 3839 stac927x_cfg_tbl); 3840 again: 3841 if (spec->board_config < 0 || !stac927x_brd_tbl[spec->board_config]) { 3842 if (spec->board_config < 0) 3843 snd_printdd(KERN_INFO "hda_codec: Unknown model for" 3844 "STAC927x, using BIOS defaults\n"); 3845 err = stac92xx_save_bios_config_regs(codec); 3846 if (err < 0) { 3847 stac92xx_free(codec); 3848 return err; 3849 } 3850 spec->pin_configs = spec->bios_pin_configs; 3851 } else { 3852 spec->pin_configs = stac927x_brd_tbl[spec->board_config]; 3853 stac92xx_set_config_regs(codec); 3854 } 3855 3856 spec->adc_nids = stac927x_adc_nids; 3857 spec->num_adcs = ARRAY_SIZE(stac927x_adc_nids); 3858 spec->mux_nids = stac927x_mux_nids; 3859 spec->num_muxes = ARRAY_SIZE(stac927x_mux_nids); 3860 spec->dac_list = stac927x_dac_nids; 3861 spec->multiout.dac_nids = spec->dac_nids; 3862 3863 switch (spec->board_config) { 3864 case STAC_D965_3ST: 3865 case STAC_D965_5ST: 3866 /* GPIO0 High = Enable EAPD */ 3867 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x01; 3868 spec->gpio_data = 0x01; 3869 spec->num_dmics = 0; 3870 3871 spec->init = d965_core_init; 3872 spec->mixer = stac927x_mixer; 3873 break; 3874 case STAC_DELL_BIOS: 3875 switch (codec->subsystem_id) { 3876 case 0x10280209: 3877 case 0x1028022e: 3878 /* correct the device field to SPDIF out */ 3879 stac92xx_set_config_reg(codec, 0x21, 0x01442070); 3880 break; 3881 }; 3882 /* configure the analog microphone on some laptops */ 3883 stac92xx_set_config_reg(codec, 0x0c, 0x90a79130); 3884 /* correct the front output jack as a hp out */ 3885 stac92xx_set_config_reg(codec, 0x0f, 0x0227011f); 3886 /* correct the front input jack as a mic */ 3887 stac92xx_set_config_reg(codec, 0x0e, 0x02a79130); 3888 /* fallthru */ 3889 case STAC_DELL_3ST: 3890 /* GPIO2 High = Enable EAPD */ 3891 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x04; 3892 spec->gpio_data = 0x04; 3893 spec->dmic_nids = stac927x_dmic_nids; 3894 spec->num_dmics = STAC927X_NUM_DMICS; 3895 3896 spec->init = d965_core_init; 3897 spec->mixer = stac927x_mixer; 3898 spec->dmux_nids = stac927x_dmux_nids; 3899 spec->num_dmuxes = ARRAY_SIZE(stac927x_dmux_nids); 3900 break; 3901 default: 3902 /* GPIO0 High = Enable EAPD */ 3903 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 3904 spec->gpio_data = 0x01; 3905 spec->num_dmics = 0; 3906 3907 spec->init = stac927x_core_init; 3908 spec->mixer = stac927x_mixer; 3909 } 3910 3911 spec->num_pwrs = 0; 3912 spec->aloopback_mask = 0x40; 3913 spec->aloopback_shift = 0; 3914 3915 err = stac92xx_parse_auto_config(codec, 0x1e, 0x20); 3916 if (!err) { 3917 if (spec->board_config < 0) { 3918 printk(KERN_WARNING "hda_codec: No auto-config is " 3919 "available, default to model=ref\n"); 3920 spec->board_config = STAC_D965_REF; 3921 goto again; 3922 } 3923 err = -EINVAL; 3924 } 3925 if (err < 0) { 3926 stac92xx_free(codec); 3927 return err; 3928 } 3929 3930 codec->patch_ops = stac92xx_patch_ops; 3931 3932 /* 3933 * !!FIXME!! 3934 * The STAC927x seem to require fairly long delays for certain 3935 * command sequences. With too short delays (even if the answer 3936 * is set to RIRB properly), it results in the silence output 3937 * on some hardwares like Dell. 3938 * 3939 * The below flag enables the longer delay (see get_response 3940 * in hda_intel.c). 3941 */ 3942 codec->bus->needs_damn_long_delay = 1; 3943 3944 return 0; 3945 } 3946 3947 static int patch_stac9205(struct hda_codec *codec) 3948 { 3949 struct sigmatel_spec *spec; 3950 int err; 3951 3952 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 3953 if (spec == NULL) 3954 return -ENOMEM; 3955 3956 codec->spec = spec; 3957 spec->num_pins = ARRAY_SIZE(stac9205_pin_nids); 3958 spec->pin_nids = stac9205_pin_nids; 3959 spec->board_config = snd_hda_check_board_config(codec, STAC_9205_MODELS, 3960 stac9205_models, 3961 stac9205_cfg_tbl); 3962 again: 3963 if (spec->board_config < 0) { 3964 snd_printdd(KERN_INFO "hda_codec: Unknown model for STAC9205, using BIOS defaults\n"); 3965 err = stac92xx_save_bios_config_regs(codec); 3966 if (err < 0) { 3967 stac92xx_free(codec); 3968 return err; 3969 } 3970 spec->pin_configs = spec->bios_pin_configs; 3971 } else { 3972 spec->pin_configs = stac9205_brd_tbl[spec->board_config]; 3973 stac92xx_set_config_regs(codec); 3974 } 3975 3976 spec->adc_nids = stac9205_adc_nids; 3977 spec->num_adcs = ARRAY_SIZE(stac9205_adc_nids); 3978 spec->mux_nids = stac9205_mux_nids; 3979 spec->num_muxes = ARRAY_SIZE(stac9205_mux_nids); 3980 spec->dmic_nids = stac9205_dmic_nids; 3981 spec->num_dmics = STAC9205_NUM_DMICS; 3982 spec->dmux_nids = stac9205_dmux_nids; 3983 spec->num_dmuxes = ARRAY_SIZE(stac9205_dmux_nids); 3984 spec->num_pwrs = 0; 3985 3986 spec->init = stac9205_core_init; 3987 spec->mixer = stac9205_mixer; 3988 3989 spec->aloopback_mask = 0x40; 3990 spec->aloopback_shift = 0; 3991 spec->multiout.dac_nids = spec->dac_nids; 3992 3993 switch (spec->board_config){ 3994 case STAC_9205_DELL_M43: 3995 /* Enable SPDIF in/out */ 3996 stac92xx_set_config_reg(codec, 0x1f, 0x01441030); 3997 stac92xx_set_config_reg(codec, 0x20, 0x1c410030); 3998 3999 /* Enable unsol response for GPIO4/Dock HP connection */ 4000 snd_hda_codec_write(codec, codec->afg, 0, 4001 AC_VERB_SET_GPIO_UNSOLICITED_RSP_MASK, 0x10); 4002 snd_hda_codec_write_cache(codec, codec->afg, 0, 4003 AC_VERB_SET_UNSOLICITED_ENABLE, 4004 (AC_USRSP_EN | STAC_HP_EVENT)); 4005 4006 spec->gpio_dir = 0x0b; 4007 spec->eapd_mask = 0x01; 4008 spec->gpio_mask = 0x1b; 4009 spec->gpio_mute = 0x10; 4010 /* GPIO0 High = EAPD, GPIO1 Low = Headphone Mute, 4011 * GPIO3 Low = DRM 4012 */ 4013 spec->gpio_data = 0x01; 4014 break; 4015 default: 4016 /* GPIO0 High = EAPD */ 4017 spec->eapd_mask = spec->gpio_mask = spec->gpio_dir = 0x1; 4018 spec->gpio_data = 0x01; 4019 break; 4020 } 4021 4022 err = stac92xx_parse_auto_config(codec, 0x1f, 0x20); 4023 if (!err) { 4024 if (spec->board_config < 0) { 4025 printk(KERN_WARNING "hda_codec: No auto-config is " 4026 "available, default to model=ref\n"); 4027 spec->board_config = STAC_9205_REF; 4028 goto again; 4029 } 4030 err = -EINVAL; 4031 } 4032 if (err < 0) { 4033 stac92xx_free(codec); 4034 return err; 4035 } 4036 4037 codec->patch_ops = stac92xx_patch_ops; 4038 4039 return 0; 4040 } 4041 4042 /* 4043 * STAC9872 hack 4044 */ 4045 4046 /* static config for Sony VAIO FE550G and Sony VAIO AR */ 4047 static hda_nid_t vaio_dacs[] = { 0x2 }; 4048 #define VAIO_HP_DAC 0x5 4049 static hda_nid_t vaio_adcs[] = { 0x8 /*,0x6*/ }; 4050 static hda_nid_t vaio_mux_nids[] = { 0x15 }; 4051 4052 static struct hda_input_mux vaio_mux = { 4053 .num_items = 3, 4054 .items = { 4055 /* { "HP", 0x0 }, */ 4056 { "Mic Jack", 0x1 }, 4057 { "Internal Mic", 0x2 }, 4058 { "PCM", 0x3 }, 4059 } 4060 }; 4061 4062 static struct hda_verb vaio_init[] = { 4063 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */ 4064 {0x0a, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | STAC_HP_EVENT}, 4065 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */ 4066 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */ 4067 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */ 4068 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */ 4069 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */ 4070 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */ 4071 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */ 4072 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */ 4073 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */ 4074 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */ 4075 {} 4076 }; 4077 4078 static struct hda_verb vaio_ar_init[] = { 4079 {0x0a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP }, /* HP <- 0x2 */ 4080 {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT }, /* Speaker <- 0x5 */ 4081 {0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? (<- 0x2) */ 4082 {0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN }, /* CD */ 4083 /* {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },*/ /* Optical Out */ 4084 {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 }, /* Mic? */ 4085 {0x15, AC_VERB_SET_CONNECT_SEL, 0x1}, /* mic-sel: 0a,0d,14,02 */ 4086 {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* HP */ 4087 {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Speaker */ 4088 /* {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},*/ /* Optical Out */ 4089 {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* capture sw/vol -> 0x8 */ 4090 {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)}, /* CD-in -> 0x6 */ 4091 {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Mic-in -> 0x9 */ 4092 {} 4093 }; 4094 4095 /* bind volumes of both NID 0x02 and 0x05 */ 4096 static struct hda_bind_ctls vaio_bind_master_vol = { 4097 .ops = &snd_hda_bind_vol, 4098 .values = { 4099 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 4100 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT), 4101 0 4102 }, 4103 }; 4104 4105 /* bind volumes of both NID 0x02 and 0x05 */ 4106 static struct hda_bind_ctls vaio_bind_master_sw = { 4107 .ops = &snd_hda_bind_sw, 4108 .values = { 4109 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT), 4110 HDA_COMPOSE_AMP_VAL(0x05, 3, 0, HDA_OUTPUT), 4111 0, 4112 }, 4113 }; 4114 4115 static struct snd_kcontrol_new vaio_mixer[] = { 4116 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol), 4117 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw), 4118 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */ 4119 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT), 4120 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT), 4121 { 4122 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4123 .name = "Capture Source", 4124 .count = 1, 4125 .info = stac92xx_mux_enum_info, 4126 .get = stac92xx_mux_enum_get, 4127 .put = stac92xx_mux_enum_put, 4128 }, 4129 {} 4130 }; 4131 4132 static struct snd_kcontrol_new vaio_ar_mixer[] = { 4133 HDA_BIND_VOL("Master Playback Volume", &vaio_bind_master_vol), 4134 HDA_BIND_SW("Master Playback Switch", &vaio_bind_master_sw), 4135 /* HDA_CODEC_VOLUME("CD Capture Volume", 0x07, 0, HDA_INPUT), */ 4136 HDA_CODEC_VOLUME("Capture Volume", 0x09, 0, HDA_INPUT), 4137 HDA_CODEC_MUTE("Capture Switch", 0x09, 0, HDA_INPUT), 4138 /*HDA_CODEC_MUTE("Optical Out Switch", 0x10, 0, HDA_OUTPUT), 4139 HDA_CODEC_VOLUME("Optical Out Volume", 0x10, 0, HDA_OUTPUT),*/ 4140 { 4141 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, 4142 .name = "Capture Source", 4143 .count = 1, 4144 .info = stac92xx_mux_enum_info, 4145 .get = stac92xx_mux_enum_get, 4146 .put = stac92xx_mux_enum_put, 4147 }, 4148 {} 4149 }; 4150 4151 static struct hda_codec_ops stac9872_patch_ops = { 4152 .build_controls = stac92xx_build_controls, 4153 .build_pcms = stac92xx_build_pcms, 4154 .init = stac92xx_init, 4155 .free = stac92xx_free, 4156 #ifdef SND_HDA_NEEDS_RESUME 4157 .resume = stac92xx_resume, 4158 #endif 4159 }; 4160 4161 static int stac9872_vaio_init(struct hda_codec *codec) 4162 { 4163 int err; 4164 4165 err = stac92xx_init(codec); 4166 if (err < 0) 4167 return err; 4168 if (codec->patch_ops.unsol_event) 4169 codec->patch_ops.unsol_event(codec, STAC_HP_EVENT << 26); 4170 return 0; 4171 } 4172 4173 static void stac9872_vaio_hp_detect(struct hda_codec *codec, unsigned int res) 4174 { 4175 if (get_hp_pin_presence(codec, 0x0a)) { 4176 stac92xx_reset_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN); 4177 stac92xx_set_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN); 4178 } else { 4179 stac92xx_reset_pinctl(codec, 0x0a, AC_PINCTL_OUT_EN); 4180 stac92xx_set_pinctl(codec, 0x0f, AC_PINCTL_OUT_EN); 4181 } 4182 } 4183 4184 static void stac9872_vaio_unsol_event(struct hda_codec *codec, unsigned int res) 4185 { 4186 switch (res >> 26) { 4187 case STAC_HP_EVENT: 4188 stac9872_vaio_hp_detect(codec, res); 4189 break; 4190 } 4191 } 4192 4193 static struct hda_codec_ops stac9872_vaio_patch_ops = { 4194 .build_controls = stac92xx_build_controls, 4195 .build_pcms = stac92xx_build_pcms, 4196 .init = stac9872_vaio_init, 4197 .free = stac92xx_free, 4198 .unsol_event = stac9872_vaio_unsol_event, 4199 #ifdef CONFIG_PM 4200 .resume = stac92xx_resume, 4201 #endif 4202 }; 4203 4204 enum { /* FE and SZ series. id=0x83847661 and subsys=0x104D0700 or 104D1000. */ 4205 CXD9872RD_VAIO, 4206 /* Unknown. id=0x83847662 and subsys=0x104D1200 or 104D1000. */ 4207 STAC9872AK_VAIO, 4208 /* Unknown. id=0x83847661 and subsys=0x104D1200. */ 4209 STAC9872K_VAIO, 4210 /* AR Series. id=0x83847664 and subsys=104D1300 */ 4211 CXD9872AKD_VAIO, 4212 STAC_9872_MODELS, 4213 }; 4214 4215 static const char *stac9872_models[STAC_9872_MODELS] = { 4216 [CXD9872RD_VAIO] = "vaio", 4217 [CXD9872AKD_VAIO] = "vaio-ar", 4218 }; 4219 4220 static struct snd_pci_quirk stac9872_cfg_tbl[] = { 4221 SND_PCI_QUIRK(0x104d, 0x81e6, "Sony VAIO F/S", CXD9872RD_VAIO), 4222 SND_PCI_QUIRK(0x104d, 0x81ef, "Sony VAIO F/S", CXD9872RD_VAIO), 4223 SND_PCI_QUIRK(0x104d, 0x81fd, "Sony VAIO AR", CXD9872AKD_VAIO), 4224 SND_PCI_QUIRK(0x104d, 0x8205, "Sony VAIO AR", CXD9872AKD_VAIO), 4225 {} 4226 }; 4227 4228 static int patch_stac9872(struct hda_codec *codec) 4229 { 4230 struct sigmatel_spec *spec; 4231 int board_config; 4232 4233 board_config = snd_hda_check_board_config(codec, STAC_9872_MODELS, 4234 stac9872_models, 4235 stac9872_cfg_tbl); 4236 if (board_config < 0) 4237 /* unknown config, let generic-parser do its job... */ 4238 return snd_hda_parse_generic_codec(codec); 4239 4240 spec = kzalloc(sizeof(*spec), GFP_KERNEL); 4241 if (spec == NULL) 4242 return -ENOMEM; 4243 4244 codec->spec = spec; 4245 switch (board_config) { 4246 case CXD9872RD_VAIO: 4247 case STAC9872AK_VAIO: 4248 case STAC9872K_VAIO: 4249 spec->mixer = vaio_mixer; 4250 spec->init = vaio_init; 4251 spec->multiout.max_channels = 2; 4252 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs); 4253 spec->multiout.dac_nids = vaio_dacs; 4254 spec->multiout.hp_nid = VAIO_HP_DAC; 4255 spec->num_adcs = ARRAY_SIZE(vaio_adcs); 4256 spec->adc_nids = vaio_adcs; 4257 spec->num_pwrs = 0; 4258 spec->input_mux = &vaio_mux; 4259 spec->mux_nids = vaio_mux_nids; 4260 codec->patch_ops = stac9872_vaio_patch_ops; 4261 break; 4262 4263 case CXD9872AKD_VAIO: 4264 spec->mixer = vaio_ar_mixer; 4265 spec->init = vaio_ar_init; 4266 spec->multiout.max_channels = 2; 4267 spec->multiout.num_dacs = ARRAY_SIZE(vaio_dacs); 4268 spec->multiout.dac_nids = vaio_dacs; 4269 spec->multiout.hp_nid = VAIO_HP_DAC; 4270 spec->num_adcs = ARRAY_SIZE(vaio_adcs); 4271 spec->num_pwrs = 0; 4272 spec->adc_nids = vaio_adcs; 4273 spec->input_mux = &vaio_mux; 4274 spec->mux_nids = vaio_mux_nids; 4275 codec->patch_ops = stac9872_patch_ops; 4276 break; 4277 } 4278 4279 return 0; 4280 } 4281 4282 4283 /* 4284 * patch entries 4285 */ 4286 struct hda_codec_preset snd_hda_preset_sigmatel[] = { 4287 { .id = 0x83847690, .name = "STAC9200", .patch = patch_stac9200 }, 4288 { .id = 0x83847882, .name = "STAC9220 A1", .patch = patch_stac922x }, 4289 { .id = 0x83847680, .name = "STAC9221 A1", .patch = patch_stac922x }, 4290 { .id = 0x83847880, .name = "STAC9220 A2", .patch = patch_stac922x }, 4291 { .id = 0x83847681, .name = "STAC9220D/9223D A2", .patch = patch_stac922x }, 4292 { .id = 0x83847682, .name = "STAC9221 A2", .patch = patch_stac922x }, 4293 { .id = 0x83847683, .name = "STAC9221D A2", .patch = patch_stac922x }, 4294 { .id = 0x83847618, .name = "STAC9227", .patch = patch_stac927x }, 4295 { .id = 0x83847619, .name = "STAC9227", .patch = patch_stac927x }, 4296 { .id = 0x83847616, .name = "STAC9228", .patch = patch_stac927x }, 4297 { .id = 0x83847617, .name = "STAC9228", .patch = patch_stac927x }, 4298 { .id = 0x83847614, .name = "STAC9229", .patch = patch_stac927x }, 4299 { .id = 0x83847615, .name = "STAC9229", .patch = patch_stac927x }, 4300 { .id = 0x83847620, .name = "STAC9274", .patch = patch_stac927x }, 4301 { .id = 0x83847621, .name = "STAC9274D", .patch = patch_stac927x }, 4302 { .id = 0x83847622, .name = "STAC9273X", .patch = patch_stac927x }, 4303 { .id = 0x83847623, .name = "STAC9273D", .patch = patch_stac927x }, 4304 { .id = 0x83847624, .name = "STAC9272X", .patch = patch_stac927x }, 4305 { .id = 0x83847625, .name = "STAC9272D", .patch = patch_stac927x }, 4306 { .id = 0x83847626, .name = "STAC9271X", .patch = patch_stac927x }, 4307 { .id = 0x83847627, .name = "STAC9271D", .patch = patch_stac927x }, 4308 { .id = 0x83847628, .name = "STAC9274X5NH", .patch = patch_stac927x }, 4309 { .id = 0x83847629, .name = "STAC9274D5NH", .patch = patch_stac927x }, 4310 { .id = 0x83847632, .name = "STAC9202", .patch = patch_stac925x }, 4311 { .id = 0x83847633, .name = "STAC9202D", .patch = patch_stac925x }, 4312 { .id = 0x83847634, .name = "STAC9250", .patch = patch_stac925x }, 4313 { .id = 0x83847635, .name = "STAC9250D", .patch = patch_stac925x }, 4314 { .id = 0x83847636, .name = "STAC9251", .patch = patch_stac925x }, 4315 { .id = 0x83847637, .name = "STAC9250D", .patch = patch_stac925x }, 4316 { .id = 0x83847645, .name = "92HD206X", .patch = patch_stac927x }, 4317 { .id = 0x83847646, .name = "92HD206D", .patch = patch_stac927x }, 4318 /* The following does not take into account .id=0x83847661 when subsys = 4319 * 104D0C00 which is STAC9225s. Because of this, some SZ Notebooks are 4320 * currently not fully supported. 4321 */ 4322 { .id = 0x83847661, .name = "CXD9872RD/K", .patch = patch_stac9872 }, 4323 { .id = 0x83847662, .name = "STAC9872AK", .patch = patch_stac9872 }, 4324 { .id = 0x83847664, .name = "CXD9872AKD", .patch = patch_stac9872 }, 4325 { .id = 0x838476a0, .name = "STAC9205", .patch = patch_stac9205 }, 4326 { .id = 0x838476a1, .name = "STAC9205D", .patch = patch_stac9205 }, 4327 { .id = 0x838476a2, .name = "STAC9204", .patch = patch_stac9205 }, 4328 { .id = 0x838476a3, .name = "STAC9204D", .patch = patch_stac9205 }, 4329 { .id = 0x838476a4, .name = "STAC9255", .patch = patch_stac9205 }, 4330 { .id = 0x838476a5, .name = "STAC9255D", .patch = patch_stac9205 }, 4331 { .id = 0x838476a6, .name = "STAC9254", .patch = patch_stac9205 }, 4332 { .id = 0x838476a7, .name = "STAC9254D", .patch = patch_stac9205 }, 4333 { .id = 0x111d7603, .name = "92HD75B3X5", .patch = patch_stac92hd71bxx}, 4334 { .id = 0x111d7608, .name = "92HD75B2X5", .patch = patch_stac92hd71bxx}, 4335 { .id = 0x111d7674, .name = "92HD73D1X5", .patch = patch_stac92hd73xx }, 4336 { .id = 0x111d7675, .name = "92HD73C1X5", .patch = patch_stac92hd73xx }, 4337 { .id = 0x111d7676, .name = "92HD73E1X5", .patch = patch_stac92hd73xx }, 4338 { .id = 0x111d76b0, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 4339 { .id = 0x111d76b1, .name = "92HD71B8X", .patch = patch_stac92hd71bxx }, 4340 { .id = 0x111d76b2, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 4341 { .id = 0x111d76b3, .name = "92HD71B7X", .patch = patch_stac92hd71bxx }, 4342 { .id = 0x111d76b4, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 4343 { .id = 0x111d76b5, .name = "92HD71B6X", .patch = patch_stac92hd71bxx }, 4344 { .id = 0x111d76b6, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 4345 { .id = 0x111d76b7, .name = "92HD71B5X", .patch = patch_stac92hd71bxx }, 4346 {} /* terminator */ 4347 }; 4348