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