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