sound/pci/hda/patch_sigmatel.c

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