SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_sigmatel.c

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