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