sound/pci/hda/patch_sigmatel.c

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