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