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