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