sound/pci/hda/patch_sigmatel.c

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