sound/pci/hda/patch_sigmatel.c

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