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