sound/pci/hda/patch_sigmatel.c

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