sound/pci/hda/patch_sigmatel.c

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