sound/pci/hda/patch_sigmatel.c

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