sound/pci/hda/patch_sigmatel.c

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